Grcov report - isle

1

// GENERATED BY ISLE. DO NOT EDIT!

2

//

3

// Generated automatically from the instruction-selection DSL code in:

4

// - src/prelude.isle

5

// - src/prelude_lower.isle

6

// - src/isa/x64/inst.isle

7

// - src/isa/x64/lower.isle

8

// - /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_lower.isle

9

10

use super::*; // Pulls in all external types.

11

use std::marker::PhantomData;

12

13

/// Context during lowering: an implementation of this trait

14

/// must be provided with all external constructors and extractors.

15

/// A mutable borrow is passed along through all lowering logic.

16

pub trait Context {

17

    fn unit(&mut self) -> Unit;

18

    fn value_type(&mut self, arg0: Value) -> Type;

19

    fn u32_nonnegative(&mut self, arg0: u32) -> Option<u32>;

20

    fn offset32(&mut self, arg0: Offset32) -> u32;

21

    fn u32_lteq(&mut self, arg0: u32, arg1: u32) -> Option<Unit>;

22

    fn u8_lteq(&mut self, arg0: u8, arg1: u8) -> Option<Unit>;

23

    fn u8_lt(&mut self, arg0: u8, arg1: u8) -> Option<Unit>;

24

    fn simm32(&mut self, arg0: Imm64) -> Option<u32>;

25

    fn uimm8(&mut self, arg0: Imm64) -> Option<u8>;

26

    fn u8_as_u32(&mut self, arg0: u8) -> u32;

27

    fn u8_as_u64(&mut self, arg0: u8) -> u64;

28

    fn u16_as_u64(&mut self, arg0: u16) -> u64;

29

    fn u32_as_u64(&mut self, arg0: u32) -> u64;

30

    fn i64_as_u64(&mut self, arg0: i64) -> u64;

31

    fn i64_neg(&mut self, arg0: i64) -> i64;

32

    fn u128_as_u64(&mut self, arg0: u128) -> Option<u64>;

33

    fn u64_as_u32(&mut self, arg0: u64) -> Option<u32>;

34

    fn u64_as_i32(&mut self, arg0: u64) -> i32;

35

    fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8;

36

    fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32;

37

    fn s32_add_fallible(&mut self, arg0: u32, arg1: u32) -> Option<u32>;

38

    fn u64_add(&mut self, arg0: u64, arg1: u64) -> u64;

39

    fn u64_sub(&mut self, arg0: u64, arg1: u64) -> u64;

40

    fn u64_mul(&mut self, arg0: u64, arg1: u64) -> u64;

41

    fn u64_sdiv(&mut self, arg0: u64, arg1: u64) -> Option<u64>;

42

    fn u64_udiv(&mut self, arg0: u64, arg1: u64) -> Option<u64>;

43

    fn u64_and(&mut self, arg0: u64, arg1: u64) -> u64;

44

    fn u64_or(&mut self, arg0: u64, arg1: u64) -> u64;

45

    fn u64_xor(&mut self, arg0: u64, arg1: u64) -> u64;

46

    fn u64_shl(&mut self, arg0: u64, arg1: u64) -> u64;

47

    fn imm64_shl(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;

48

    fn imm64_ushr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;

49

    fn imm64_sshr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;

50

    fn u64_not(&mut self, arg0: u64) -> u64;

51

    fn u64_eq(&mut self, arg0: u64, arg1: u64) -> bool;

52

    fn u64_le(&mut self, arg0: u64, arg1: u64) -> bool;

53

    fn u64_lt(&mut self, arg0: u64, arg1: u64) -> bool;

54

    fn i64_sextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> i64;

55

    fn u64_uextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> u64;

56

    fn imm64_icmp(&mut self, arg0: Type, arg1: &IntCC, arg2: Imm64, arg3: Imm64) -> Imm64;

57

    fn u64_is_zero(&mut self, arg0: u64) -> bool;

58

    fn u64_is_odd(&mut self, arg0: u64) -> bool;

59

    fn ty_umin(&mut self, arg0: Type) -> u64;

60

    fn ty_umax(&mut self, arg0: Type) -> u64;

61

    fn ty_smin(&mut self, arg0: Type) -> u64;

62

    fn ty_smax(&mut self, arg0: Type) -> u64;

63

    fn ty_bits(&mut self, arg0: Type) -> u8;

64

    fn ty_bits_u16(&mut self, arg0: Type) -> u16;

65

    fn ty_bits_u64(&mut self, arg0: Type) -> u64;

66

    fn ty_mask(&mut self, arg0: Type) -> u64;

67

    fn ty_bytes(&mut self, arg0: Type) -> u16;

68

    fn lane_type(&mut self, arg0: Type) -> Type;

69

    fn mem_flags_trusted(&mut self) -> MemFlags;

70

    fn intcc_reverse(&mut self, arg0: &IntCC) -> IntCC;

71

    fn intcc_inverse(&mut self, arg0: &IntCC) -> IntCC;

72

    fn floatcc_reverse(&mut self, arg0: &FloatCC) -> FloatCC;

73

    fn floatcc_inverse(&mut self, arg0: &FloatCC) -> FloatCC;

74

    fn floatcc_unordered(&mut self, arg0: &FloatCC) -> bool;

75

    fn fits_in_16(&mut self, arg0: Type) -> Option<Type>;

76

    fn fits_in_32(&mut self, arg0: Type) -> Option<Type>;

77

    fn lane_fits_in_32(&mut self, arg0: Type) -> Option<Type>;

78

    fn fits_in_64(&mut self, arg0: Type) -> Option<Type>;

79

    fn ty_32(&mut self, arg0: Type) -> Option<Type>;

80

    fn ty_64(&mut self, arg0: Type) -> Option<Type>;

81

    fn ty_int_ref_scalar_64(&mut self, arg0: Type) -> Option<Type>;

82

    fn ty_32_or_64(&mut self, arg0: Type) -> Option<Type>;

83

    fn ty_8_or_16(&mut self, arg0: Type) -> Option<Type>;

84

    fn int_fits_in_32(&mut self, arg0: Type) -> Option<Type>;

85

    fn ty_int_ref_64(&mut self, arg0: Type) -> Option<Type>;

86

    fn ty_int(&mut self, arg0: Type) -> Option<Type>;

87

    fn ty_scalar_float(&mut self, arg0: Type) -> Option<Type>;

88

    fn ty_float_or_vec(&mut self, arg0: Type) -> Option<Type>;

89

    fn ty_vector_float(&mut self, arg0: Type) -> Option<Type>;

90

    fn ty_vector_not_float(&mut self, arg0: Type) -> Option<Type>;

91

    fn ty_vec64(&mut self, arg0: Type) -> Option<Type>;

92

    fn ty_vec64_ctor(&mut self, arg0: Type) -> Option<Type>;

93

    fn ty_vec128(&mut self, arg0: Type) -> Option<Type>;

94

    fn ty_dyn_vec64(&mut self, arg0: Type) -> Option<Type>;

95

    fn ty_dyn_vec128(&mut self, arg0: Type) -> Option<Type>;

96

    fn ty_vec64_int(&mut self, arg0: Type) -> Option<Type>;

97

    fn ty_vec128_int(&mut self, arg0: Type) -> Option<Type>;

98

    fn ty_addr64(&mut self, arg0: Type) -> Option<Type>;

99

    fn not_vec32x2(&mut self, arg0: Type) -> Option<Type>;

100

    fn not_i64x2(&mut self, arg0: Type) -> Option<()>;

101

    fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;

102

    fn u64_from_bool(&mut self, arg0: bool) -> u64;

103

    fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;

104

    fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;

105

    fn imm64_power_of_two(&mut self, arg0: Imm64) -> Option<u64>;

106

    fn imm64(&mut self, arg0: u64) -> Imm64;

107

    fn imm64_masked(&mut self, arg0: Type, arg1: u64) -> Imm64;

108

    fn u32_from_ieee32(&mut self, arg0: Ieee32) -> u32;

109

    fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;

110

    fn multi_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;

111

    fn dynamic_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;

112

    fn dynamic_int_lane(&mut self, arg0: Type) -> Option<u32>;

113

    fn dynamic_fp_lane(&mut self, arg0: Type) -> Option<u32>;

114

    fn ty_dyn64_int(&mut self, arg0: Type) -> Option<Type>;

115

    fn ty_dyn128_int(&mut self, arg0: Type) -> Option<Type>;

116

    fn offset32_to_u32(&mut self, arg0: Offset32) -> u32;

117

    fn u32_to_offset32(&mut self, arg0: u32) -> Offset32;

118

    fn intcc_unsigned(&mut self, arg0: &IntCC) -> IntCC;

119

    fn signed_cond_code(&mut self, arg0: &IntCC) -> Option<IntCC>;

120

    fn trap_code_division_by_zero(&mut self) -> TrapCode;

121

    fn trap_code_integer_overflow(&mut self) -> TrapCode;

122

    fn trap_code_bad_conversion_to_integer(&mut self) -> TrapCode;

123

    fn range(&mut self, arg0: usize, arg1: usize) -> Range;

124

    fn range_view(&mut self, arg0: Range) -> RangeView;

125

    fn value_reg(&mut self, arg0: Reg) -> ValueRegs;

126

    fn value_regs(&mut self, arg0: Reg, arg1: Reg) -> ValueRegs;

127

    fn value_regs_invalid(&mut self) -> ValueRegs;

128

    fn output_none(&mut self) -> InstOutput;

129

    fn output(&mut self, arg0: ValueRegs) -> InstOutput;

130

    fn output_pair(&mut self, arg0: ValueRegs, arg1: ValueRegs) -> InstOutput;

131

    fn output_builder_new(&mut self) -> InstOutputBuilder;

132

    fn output_builder_push(&mut self, arg0: &InstOutputBuilder, arg1: ValueRegs) -> Unit;

133

    fn output_builder_finish(&mut self, arg0: &InstOutputBuilder) -> InstOutput;

134

    fn temp_writable_reg(&mut self, arg0: Type) -> WritableReg;

135

    fn is_valid_reg(&mut self, arg0: Reg) -> bool;

136

    fn invalid_reg(&mut self) -> Reg;

137

    fn mark_value_used(&mut self, arg0: Value) -> Unit;

138

    fn put_in_reg(&mut self, arg0: Value) -> Reg;

139

    fn put_in_regs(&mut self, arg0: Value) -> ValueRegs;

140

    fn ensure_in_vreg(&mut self, arg0: Reg, arg1: Type) -> Reg;

141

    fn value_regs_get(&mut self, arg0: ValueRegs, arg1: usize) -> Reg;

142

    fn value_regs_len(&mut self, arg0: ValueRegs) -> usize;

143

    fn preg_to_reg(&mut self, arg0: PReg) -> Reg;

144

    fn value_list_slice(&mut self, arg0: ValueList) -> ValueSlice;

145

    fn value_slice_empty(&mut self, arg0: ValueSlice) -> Option<()>;

146

    fn value_slice_unwrap(&mut self, arg0: ValueSlice) -> Option<(Value, ValueSlice)>;

147

    fn value_slice_len(&mut self, arg0: ValueSlice) -> usize;

148

    fn value_slice_get(&mut self, arg0: ValueSlice, arg1: usize) -> Value;

149

    fn writable_reg_to_reg(&mut self, arg0: WritableReg) -> Reg;

150

    fn inst_results(&mut self, arg0: Inst) -> ValueSlice;

151

    fn first_result(&mut self, arg0: Inst) -> Option<Value>;

152

    fn inst_data(&mut self, arg0: Inst) -> InstructionData;

153

    fn def_inst(&mut self, arg0: Value) -> Option<Inst>;

154

    fn zero_value(&mut self, arg0: Value) -> Option<Value>;

155

    fn is_sinkable_inst(&mut self, arg0: Value) -> Option<Inst>;

156

    fn maybe_uextend(&mut self, arg0: Value) -> Option<Value>;

157

    fn emit(&mut self, arg0: &MInst) -> Unit;

158

    fn sink_inst(&mut self, arg0: Inst) -> Unit;

159

    fn emit_u64_le_const(&mut self, arg0: u64) -> VCodeConstant;

160

    fn emit_u128_le_const(&mut self, arg0: u128) -> VCodeConstant;

161

    fn const_to_vconst(&mut self, arg0: Constant) -> VCodeConstant;

162

    fn tls_model(&mut self, arg0: Type) -> TlsModel;

163

    fn tls_model_is_elf_gd(&mut self) -> Option<Unit>;

164

    fn tls_model_is_macho(&mut self) -> Option<Unit>;

165

    fn tls_model_is_coff(&mut self) -> Option<Unit>;

166

    fn preserve_frame_pointers(&mut self) -> Option<Unit>;

167

    fn box_external_name(&mut self, arg0: ExternalName) -> BoxExternalName;

168

    fn func_ref_data(&mut self, arg0: FuncRef) -> (SigRef, ExternalName, RelocDistance);

169

    fn symbol_value_data(

170

        &mut self,

171

        arg0: GlobalValue,

172

    ) -> Option<(ExternalName, RelocDistance, i64)>;

173

    fn reloc_distance_near(&mut self, arg0: RelocDistance) -> Option<()>;

174

    fn vec_mask_from_immediate(&mut self, arg0: Immediate) -> Option<VecMask>;

175

    fn u128_from_immediate(&mut self, arg0: Immediate) -> Option<u128>;

176

    fn u128_from_constant(&mut self, arg0: Constant) -> Option<u128>;

177

    fn u64_from_constant(&mut self, arg0: Constant) -> Option<u64>;

178

    fn shuffle64_from_imm(&mut self, arg0: Immediate) -> Option<(u8, u8)>;

179

    fn shuffle32_from_imm(&mut self, arg0: Immediate) -> Option<(u8, u8, u8, u8)>;

180

    fn shuffle16_from_imm(&mut self, arg0: Immediate) -> Option<(u8, u8, u8, u8, u8, u8, u8, u8)>;

181

    fn only_writable_reg(&mut self, arg0: WritableValueRegs) -> Option<WritableReg>;

182

    fn writable_regs_get(&mut self, arg0: WritableValueRegs, arg1: usize) -> WritableReg;

183

    fn abi_num_args(&mut self, arg0: Sig) -> usize;

184

    fn abi_get_arg(&mut self, arg0: Sig, arg1: usize) -> ABIArg;

185

    fn abi_num_rets(&mut self, arg0: Sig) -> usize;

186

    fn abi_get_ret(&mut self, arg0: Sig, arg1: usize) -> ABIArg;

187

    fn abi_ret_arg(&mut self, arg0: Sig) -> Option<ABIArg>;

188

    fn abi_no_ret_arg(&mut self, arg0: Sig) -> Option<()>;

189

    fn abi_sized_stack_arg_space(&mut self, arg0: Sig) -> i64;

190

    fn abi_sized_stack_ret_space(&mut self, arg0: Sig) -> i64;

191

    fn abi_stackslot_addr(&mut self, arg0: WritableReg, arg1: StackSlot, arg2: Offset32) -> MInst;

192

    fn abi_dynamic_stackslot_addr(&mut self, arg0: WritableReg, arg1: DynamicStackSlot) -> MInst;

193

    fn abi_arg_only_slot(&mut self, arg0: &ABIArg) -> Option<ABIArgSlot>;

194

    fn abi_arg_struct_pointer(&mut self, arg0: &ABIArg) -> Option<(ABIArgSlot, i64, u64)>;

195

    fn abi_arg_implicit_pointer(&mut self, arg0: &ABIArg) -> Option<(ABIArgSlot, i64, Type)>;

196

    fn real_reg_to_reg(&mut self, arg0: RealReg) -> Reg;

197

    fn real_reg_to_writable_reg(&mut self, arg0: RealReg) -> WritableReg;

198

    fn gen_move(&mut self, arg0: Type, arg1: WritableReg, arg2: Reg) -> MInst;

199

    fn gen_return(&mut self, arg0: ValueSlice) -> Unit;

200

    fn safe_divisor_from_imm64(&mut self, arg0: Type, arg1: Imm64) -> Option<u64>;

201

    fn jump_table_size(&mut self, arg0: &BoxVecMachLabel) -> u32;

202

    fn single_target(&mut self, arg0: &MachLabelSlice) -> Option<MachLabel>;

203

    fn two_targets(&mut self, arg0: &MachLabelSlice) -> Option<(MachLabel, MachLabel)>;

204

    fn jump_table_targets(&mut self, arg0: &MachLabelSlice)

205

        -> Option<(MachLabel, BoxVecMachLabel)>;

206

    fn operand_size_of_type_32_64(&mut self, arg0: Type) -> OperandSize;

207

    fn raw_operand_size_of_type(&mut self, arg0: Type) -> OperandSize;

208

    fn put_in_reg_mem_imm(&mut self, arg0: Value) -> RegMemImm;

209

    fn put_in_reg_mem(&mut self, arg0: Value) -> RegMem;

210

    fn synthetic_amode_to_reg_mem(&mut self, arg0: &SyntheticAmode) -> RegMem;

211

    fn amode_to_synthetic_amode(&mut self, arg0: &Amode) -> SyntheticAmode;

212

    fn sum_extend_fits_in_32_bits(

213

        &mut self,

214

        arg0: Type,

215

        arg1: Imm64,

216

        arg2: Offset32,

217

    ) -> Option<u32>;

218

    fn amode_offset(&mut self, arg0: &Amode, arg1: u32) -> Amode;

219

    fn zero_offset(&mut self) -> Offset32;

220

    fn intcc_to_cc(&mut self, arg0: &IntCC) -> CC;

221

    fn cc_invert(&mut self, arg0: &CC) -> CC;

222

    fn cc_nz_or_z(&mut self, arg0: &CC) -> Option<CC>;

223

    fn encode_fcmp_imm(&mut self, arg0: &FcmpImm) -> u8;

224

    fn encode_round_imm(&mut self, arg0: &RoundImm) -> u8;

225

    fn imm8_reg_to_imm8_gpr(&mut self, arg0: &Imm8Reg) -> Imm8Gpr;

226

    fn writable_gpr_to_reg(&mut self, arg0: WritableGpr) -> WritableReg;

227

    fn writable_xmm_to_reg(&mut self, arg0: WritableXmm) -> WritableReg;

228

    fn writable_reg_to_xmm(&mut self, arg0: WritableReg) -> WritableXmm;

229

    fn writable_xmm_to_xmm(&mut self, arg0: WritableXmm) -> Xmm;

230

    fn writable_gpr_to_gpr(&mut self, arg0: WritableGpr) -> Gpr;

231

    fn gpr_to_reg(&mut self, arg0: Gpr) -> Reg;

232

    fn gpr_to_gpr_mem(&mut self, arg0: Gpr) -> GprMem;

233

    fn gpr_to_gpr_mem_imm(&mut self, arg0: Gpr) -> GprMemImm;

234

    fn xmm_to_reg(&mut self, arg0: Xmm) -> Reg;

235

    fn xmm_to_xmm_mem_imm(&mut self, arg0: Xmm) -> XmmMemImm;

236

    fn xmm_mem_to_xmm_mem_imm(&mut self, arg0: &XmmMem) -> XmmMemImm;

237

    fn xmm_mem_to_xmm_mem_aligned(&mut self, arg0: &XmmMem) -> XmmMemAligned;

238

    fn xmm_mem_imm_to_xmm_mem_aligned_imm(&mut self, arg0: &XmmMemImm) -> XmmMemAlignedImm;

239

    fn temp_writable_gpr(&mut self) -> WritableGpr;

240

    fn temp_writable_xmm(&mut self) -> WritableXmm;

241

    fn reg_mem_to_xmm_mem(&mut self, arg0: &RegMem) -> XmmMem;

242

    fn reg_to_reg_mem_imm(&mut self, arg0: Reg) -> RegMemImm;

243

    fn gpr_mem_imm_new(&mut self, arg0: &RegMemImm) -> GprMemImm;

244

    fn xmm_mem_imm_new(&mut self, arg0: &RegMemImm) -> XmmMemImm;

245

    fn xmm_to_xmm_mem(&mut self, arg0: Xmm) -> XmmMem;

246

    fn xmm_mem_to_reg_mem(&mut self, arg0: &XmmMem) -> RegMem;

247

    fn gpr_mem_to_reg_mem(&mut self, arg0: &GprMem) -> RegMem;

248

    fn xmm_new(&mut self, arg0: Reg) -> Xmm;

249

    fn gpr_new(&mut self, arg0: Reg) -> Gpr;

250

    fn reg_mem_to_gpr_mem(&mut self, arg0: &RegMem) -> GprMem;

251

    fn reg_to_gpr_mem(&mut self, arg0: Reg) -> GprMem;

252

    fn put_in_xmm_mem(&mut self, arg0: Value) -> XmmMem;

253

    fn put_in_xmm_mem_imm(&mut self, arg0: Value) -> XmmMemImm;

254

    fn gpr_to_imm8_gpr(&mut self, arg0: Gpr) -> Imm8Gpr;

255

    fn imm8_to_imm8_gpr(&mut self, arg0: u8) -> Imm8Gpr;

256

    fn xmi_imm(&mut self, arg0: u32) -> XmmMemImm;

257

    fn intcc_without_eq(&mut self, arg0: &IntCC) -> IntCC;

258

    fn type_register_class(&mut self, arg0: Type) -> Option<RegisterClass>;

259

    fn avx512vl_enabled(&mut self, arg0: Type) -> bool;

260

    fn avx512dq_enabled(&mut self, arg0: Type) -> bool;

261

    fn avx512f_enabled(&mut self, arg0: Type) -> bool;

262

    fn avx512bitalg_enabled(&mut self, arg0: Type) -> bool;

263

    fn avx512vbmi_enabled(&mut self, arg0: Type) -> bool;

264

    fn use_lzcnt(&mut self, arg0: Type) -> bool;

265

    fn use_bmi1(&mut self, arg0: Type) -> bool;

266

    fn use_popcnt(&mut self, arg0: Type) -> bool;

267

    fn use_fma(&mut self) -> bool;

268

    fn use_sse41(&mut self, arg0: Type) -> bool;

269

    fn use_avx_simd(&mut self) -> bool;

270

    fn use_avx2_simd(&mut self) -> bool;

271

    fn imm8_from_value(&mut self, arg0: Value) -> Option<Imm8Reg>;

272

    fn const_to_type_masked_imm8(&mut self, arg0: u64, arg1: Type) -> Imm8Gpr;

273

    fn shift_mask(&mut self, arg0: Type) -> u32;

274

    fn shift_amount_masked(&mut self, arg0: Type, arg1: Imm64) -> u32;

275

    fn simm32_from_value(&mut self, arg0: Value) -> Option<GprMemImm>;

276

    fn simm32_from_imm64(&mut self, arg0: Imm64) -> Option<GprMemImm>;

277

    fn sinkable_load(&mut self, arg0: Value) -> Option<SinkableLoad>;

278

    fn sinkable_load_exact(&mut self, arg0: Value) -> Option<SinkableLoad>;

279

    fn sink_load(&mut self, arg0: &SinkableLoad) -> SyntheticAmode;

280

    fn ext_mode(&mut self, arg0: u16, arg1: u16) -> ExtMode;

281

    fn gen_call(

282

        &mut self,

283

        arg0: SigRef,

284

        arg1: ExternalName,

285

        arg2: RelocDistance,

286

        arg3: ValueSlice,

287

    ) -> InstOutput;

288

    fn gen_call_indirect(&mut self, arg0: SigRef, arg1: Value, arg2: ValueSlice) -> InstOutput;

289

    fn nonzero_u64_fits_in_u32(&mut self, arg0: u64) -> Option<u64>;

290

    fn fcvt_uint_mask_const(&mut self) -> VCodeConstant;

291

    fn fcvt_uint_mask_high_const(&mut self) -> VCodeConstant;

292

    fn iadd_pairwise_mul_const_16(&mut self) -> VCodeConstant;

293

    fn iadd_pairwise_mul_const_32(&mut self) -> VCodeConstant;

294

    fn iadd_pairwise_xor_const_32(&mut self) -> VCodeConstant;

295

    fn iadd_pairwise_addd_const_32(&mut self) -> VCodeConstant;

296

    fn snarrow_umax_mask(&mut self) -> VCodeConstant;

297

    fn ty_int_bool_or_ref(&mut self, arg0: Type) -> Option<()>;

298

    fn atomic_rmw_op_to_mach_atomic_rmw_op(&mut self, arg0: &AtomicRmwOp) -> MachAtomicRmwOp;

299

    fn shuffle_0_31_mask(&mut self, arg0: &VecMask) -> VCodeConstant;

300

    fn shuffle_0_15_mask(&mut self, arg0: &VecMask) -> VCodeConstant;

301

    fn shuffle_16_31_mask(&mut self, arg0: &VecMask) -> VCodeConstant;

302

    fn perm_from_mask(&mut self, arg0: &VecMask) -> VCodeConstant;

303

    fn perm_from_mask_with_zeros(

304

        &mut self,

305

        arg0: &VecMask,

306

    ) -> Option<(VCodeConstant, VCodeConstant)>;

307

    fn swizzle_zero_mask(&mut self) -> VCodeConstant;

308

    fn sqmul_round_sat_mask(&mut self) -> VCodeConstant;

309

    fn uunarrow_umax_mask(&mut self) -> VCodeConstant;

310

    fn uunarrow_uint_mask(&mut self) -> VCodeConstant;

311

    fn const_to_synthetic_amode(&mut self, arg0: VCodeConstant) -> SyntheticAmode;

312

    fn preg_rbp(&mut self) -> PReg;

313

    fn preg_rsp(&mut self) -> PReg;

314

    fn preg_pinned(&mut self) -> PReg;

315

    fn libcall_1(&mut self, arg0: &LibCall, arg1: Reg) -> Reg;

316

    fn libcall_3(&mut self, arg0: &LibCall, arg1: Reg, arg2: Reg, arg3: Reg) -> Reg;

317

    fn ishl_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;

318

    fn ishl_i8x16_mask_table(&mut self) -> SyntheticAmode;

319

    fn ushr_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;

320

    fn ushr_i8x16_mask_table(&mut self) -> SyntheticAmode;

321

    fn vconst_all_ones_or_all_zeros(&mut self, arg0: Constant) -> Option<()>;

322

    fn sse_insertps_lane_imm(&mut self, arg0: u8) -> u8;

323

    fn popcount_4bit_table(&mut self) -> VCodeConstant;

324

    fn popcount_low_mask(&mut self) -> VCodeConstant;

325

    fn pblendw_imm(&mut self, arg0: Immediate) -> Option<u8>;

326

    fn palignr_imm_from_immediate(&mut self, arg0: Immediate) -> Option<u8>;

327

    fn pshuflw_lhs_imm(&mut self, arg0: Immediate) -> Option<u8>;

328

    fn pshuflw_rhs_imm(&mut self, arg0: Immediate) -> Option<u8>;

329

    fn pshufhw_lhs_imm(&mut self, arg0: Immediate) -> Option<u8>;

330

    fn pshufhw_rhs_imm(&mut self, arg0: Immediate) -> Option<u8>;

331

    fn pshufd_lhs_imm(&mut self, arg0: Immediate) -> Option<u8>;

332

    fn pshufd_rhs_imm(&mut self, arg0: Immediate) -> Option<u8>;

333

    fn shufps_imm(&mut self, arg0: Immediate) -> Option<u8>;

334

    fn shufps_rev_imm(&mut self, arg0: Immediate) -> Option<u8>;

335

    fn unpack_value_array_2(&mut self, arg0: &ValueArray2) -> (Value, Value);

336

    fn pack_value_array_2(&mut self, arg0: Value, arg1: Value) -> ValueArray2;

337

    fn unpack_value_array_3(&mut self, arg0: &ValueArray3) -> (Value, Value, Value);

338

    fn pack_value_array_3(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;

339

    fn unpack_block_array_2(&mut self, arg0: &BlockArray2) -> (BlockCall, BlockCall);

340

    fn pack_block_array_2(&mut self, arg0: BlockCall, arg1: BlockCall) -> BlockArray2;

341

342

343

pub trait ContextIter {

344

    type Context;

345

    type Output;

346

    fn next(&mut self, ctx: &mut Self::Context) -> Option<Self::Output>;

347

348

349

pub struct ContextIterWrapper<Item, I: Iterator<Item = Item>, C: Context> {

350

    iter: I,

351

    _ctx: PhantomData<C>,

352

353

impl<Item, I: Iterator<Item = Item>, C: Context> From<I> for ContextIterWrapper<Item, I, C> {

354

    fn from(iter: I) -> Self {

355

        Self {

356

            iter,

357

            _ctx: PhantomData,

358

359

360

361

impl<Item, I: Iterator<Item = Item>, C: Context> ContextIter for ContextIterWrapper<Item, I, C> {

362

    type Context = C;

363

    type Output = Item;

364

    fn next(&mut self, _ctx: &mut Self::Context) -> Option<Self::Output> {

365

        self.iter.next()

366

367

368

369

/// Internal type SideEffectNoResult: defined at src/prelude_lower.isle line 282.

370

#[derive(Clone, Debug)]

371

pub enum SideEffectNoResult {

372

    Inst {

373

        inst: MInst,

374

},

375

    Inst2 {

376

        inst1: MInst,

377

        inst2: MInst,

378

},

379

    Inst3 {

380

        inst1: MInst,

381

        inst2: MInst,

382

        inst3: MInst,

383

},

384

385

386

/// Internal type ProducesFlags: defined at src/prelude_lower.isle line 324.

387

#[derive(Clone, Debug)]

388

pub enum ProducesFlags {

389

    AlreadyExistingFlags,

390

    ProducesFlagsSideEffect { inst: MInst },

391

    ProducesFlagsTwiceSideEffect { inst1: MInst, inst2: MInst },

392

    ProducesFlagsReturnsReg { inst: MInst, result: Reg },

393

    ProducesFlagsReturnsResultWithConsumer { inst: MInst, result: Reg },

394

395

396

/// Internal type ConsumesFlags: defined at src/prelude_lower.isle line 346.

397

#[derive(Clone, Debug)]

398

pub enum ConsumesFlags {

399

    ConsumesFlagsSideEffect {

400

        inst: MInst,

401

},

402

    ConsumesFlagsSideEffect2 {

403

        inst1: MInst,

404

        inst2: MInst,

405

},

406

    ConsumesFlagsReturnsResultWithProducer {

407

        inst: MInst,

408

        result: Reg,

409

},

410

    ConsumesFlagsReturnsReg {

411

        inst: MInst,

412

        result: Reg,

413

},

414

    ConsumesFlagsTwiceReturnsValueRegs {

415

        inst1: MInst,

416

        inst2: MInst,

417

        result: ValueRegs,

418

},

419

    ConsumesFlagsFourTimesReturnsValueRegs {

420

        inst1: MInst,

421

        inst2: MInst,

422

        inst3: MInst,

423

        inst4: MInst,

424

        result: ValueRegs,

425

},

426

427

428

/// Internal type MInst: defined at src/isa/x64/inst.isle line 8.

429

#[derive(Clone)]

430

pub enum MInst {

431

    Nop {

432

        len: u8,

433

},

434

    AluRmiR {

435

        size: OperandSize,

436

        op: AluRmiROpcode,

437

        src1: Gpr,

438

        src2: GprMemImm,

439

        dst: WritableGpr,

440

},

441

    AluRM {

442

        size: OperandSize,

443

        op: AluRmiROpcode,

444

        src1_dst: SyntheticAmode,

445

        src2: Gpr,

446

},

447

    AluRmRVex {

448

        size: OperandSize,

449

        op: AluRmROpcode,

450

        src1: Gpr,

451

        src2: Gpr,

452

        dst: WritableGpr,

453

},

454

    AluConstOp {

455

        op: AluRmiROpcode,

456

        size: OperandSize,

457

        dst: WritableGpr,

458

},

459

    UnaryRmR {

460

        size: OperandSize,

461

        op: UnaryRmROpcode,

462

        src: GprMem,

463

        dst: WritableGpr,

464

},

465

    Not {

466

        size: OperandSize,

467

        src: Gpr,

468

        dst: WritableGpr,

469

},

470

    Neg {

471

        size: OperandSize,

472

        src: Gpr,

473

        dst: WritableGpr,

474

},

475

    Div {

476

        size: OperandSize,

477

        sign: DivSignedness,

478

        trap: TrapCode,

479

        divisor: GprMem,

480

        dividend_lo: Gpr,

481

        dividend_hi: Gpr,

482

        dst_quotient: WritableGpr,

483

        dst_remainder: WritableGpr,

484

},

485

    Div8 {

486

        sign: DivSignedness,

487

        trap: TrapCode,

488

        divisor: GprMem,

489

        dividend: Gpr,

490

        dst: WritableGpr,

491

},

492

    MulHi {

493

        size: OperandSize,

494

        signed: bool,

495

        src1: Gpr,

496

        src2: GprMem,

497

        dst_lo: WritableGpr,

498

        dst_hi: WritableGpr,

499

},

500

    CheckedSRemSeq {

501

        size: OperandSize,

502

        dividend_lo: Gpr,

503

        dividend_hi: Gpr,

504

        divisor: Gpr,

505

        dst_quotient: WritableGpr,

506

        dst_remainder: WritableGpr,

507

},

508

    CheckedSRemSeq8 {

509

        dividend: Gpr,

510

        divisor: Gpr,

511

        dst: WritableGpr,

512

},

513

    SignExtendData {

514

        size: OperandSize,

515

        src: Gpr,

516

        dst: WritableGpr,

517

},

518

    Imm {

519

        dst_size: OperandSize,

520

        simm64: u64,

521

        dst: WritableGpr,

522

},

523

    MovRR {

524

        size: OperandSize,

525

        src: Gpr,

526

        dst: WritableGpr,

527

},

528

    MovFromPReg {

529

        src: PReg,

530

        dst: WritableGpr,

531

},

532

    MovToPReg {

533

        src: Gpr,

534

        dst: PReg,

535

},

536

    MovzxRmR {

537

        ext_mode: ExtMode,

538

        src: GprMem,

539

        dst: WritableGpr,

540

},

541

    Mov64MR {

542

        src: SyntheticAmode,

543

        dst: WritableGpr,

544

},

545

    LoadEffectiveAddress {

546

        addr: SyntheticAmode,

547

        dst: WritableGpr,

548

        size: OperandSize,

549

},

550

    MovsxRmR {

551

        ext_mode: ExtMode,

552

        src: GprMem,

553

        dst: WritableGpr,

554

},

555

    MovImmM {

556

        size: OperandSize,

557

        simm64: u64,

558

        dst: SyntheticAmode,

559

},

560

    MovRM {

561

        size: OperandSize,

562

        src: Gpr,

563

        dst: SyntheticAmode,

564

},

565

    ShiftR {

566

        size: OperandSize,

567

        kind: ShiftKind,

568

        src: Gpr,

569

        num_bits: Imm8Gpr,

570

        dst: WritableGpr,

571

},

572

    XmmRmiReg {

573

        opcode: SseOpcode,

574

        src1: Xmm,

575

        src2: XmmMemAlignedImm,

576

        dst: WritableXmm,

577

},

578

    CmpRmiR {

579

        size: OperandSize,

580

        opcode: CmpOpcode,

581

        src: GprMemImm,

582

        dst: Gpr,

583

},

584

    Setcc {

585

        cc: CC,

586

        dst: WritableGpr,

587

},

588

    Bswap {

589

        size: OperandSize,

590

        src: Gpr,

591

        dst: WritableGpr,

592

},

593

    Cmove {

594

        size: OperandSize,

595

        cc: CC,

596

        consequent: GprMem,

597

        alternative: Gpr,

598

        dst: WritableGpr,

599

},

600

    XmmCmove {

601

        ty: Type,

602

        cc: CC,

603

        consequent: XmmMemAligned,

604

        alternative: Xmm,

605

        dst: WritableXmm,

606

},

607

    Push64 {

608

        src: GprMemImm,

609

},

610

    Pop64 {

611

        dst: WritableGpr,

612

},

613

    StackProbeLoop {

614

        tmp: WritableReg,

615

        frame_size: u32,

616

        guard_size: u32,

617

},

618

    XmmRmR {

619

        op: SseOpcode,

620

        src1: Xmm,

621

        src2: XmmMemAligned,

622

        dst: WritableXmm,

623

},

624

    XmmRmRUnaligned {

625

        op: SseOpcode,

626

        src1: Xmm,

627

        src2: XmmMem,

628

        dst: WritableXmm,

629

},

630

    XmmRmRBlend {

631

        op: SseOpcode,

632

        src1: Xmm,

633

        src2: XmmMemAligned,

634

        mask: Xmm,

635

        dst: WritableXmm,

636

},

637

    XmmRmiRVex {

638

        op: AvxOpcode,

639

        src1: Xmm,

640

        src2: XmmMemImm,

641

        dst: WritableXmm,

642

},

643

    XmmRmRImmVex {

644

        op: AvxOpcode,

645

        src1: Xmm,

646

        src2: XmmMem,

647

        dst: WritableXmm,

648

        imm: u8,

649

},

650

    XmmVexPinsr {

651

        op: AvxOpcode,

652

        src1: Xmm,

653

        src2: GprMem,

654

        dst: WritableXmm,

655

        imm: u8,

656

},

657

    XmmRmRVex3 {

658

        op: AvxOpcode,

659

        src1: Xmm,

660

        src2: Xmm,

661

        src3: XmmMem,

662

        dst: WritableXmm,

663

},

664

    XmmRmRBlendVex {

665

        op: AvxOpcode,

666

        src1: Xmm,

667

        src2: XmmMem,

668

        mask: Xmm,

669

        dst: WritableXmm,

670

},

671

    XmmUnaryRmRVex {

672

        op: AvxOpcode,

673

        src: XmmMem,

674

        dst: WritableXmm,

675

},

676

    XmmUnaryRmRImmVex {

677

        op: AvxOpcode,

678

        src: XmmMem,

679

        dst: WritableXmm,

680

        imm: u8,

681

},

682

    XmmMovRMVex {

683

        op: AvxOpcode,

684

        src: Xmm,

685

        dst: SyntheticAmode,

686

},

687

    XmmMovRMImmVex {

688

        op: AvxOpcode,

689

        src: Xmm,

690

        dst: SyntheticAmode,

691

        imm: u8,

692

},

693

    XmmToGprImmVex {

694

        op: AvxOpcode,

695

        src: Xmm,

696

        dst: WritableGpr,

697

        imm: u8,

698

},

699

    GprToXmmVex {

700

        op: AvxOpcode,

701

        src: GprMem,

702

        dst: WritableXmm,

703

        src_size: OperandSize,

704

},

705

    XmmToGprVex {

706

        op: AvxOpcode,

707

        src: Xmm,

708

        dst: WritableGpr,

709

        dst_size: OperandSize,

710

},

711

    XmmRmREvex {

712

        op: Avx512Opcode,

713

        src1: XmmMem,

714

        src2: Xmm,

715

        dst: WritableXmm,

716

},

717

    XmmRmREvex3 {

718

        op: Avx512Opcode,

719

        src1: XmmMem,

720

        src2: Xmm,

721

        src3: Xmm,

722

        dst: WritableXmm,

723

},

724

    XmmUnaryRmR {

725

        op: SseOpcode,

726

        src: XmmMemAligned,

727

        dst: WritableXmm,

728

},

729

    XmmUnaryRmRUnaligned {

730

        op: SseOpcode,

731

        src: XmmMem,

732

        dst: WritableXmm,

733

},

734

    XmmUnaryRmRImm {

735

        op: SseOpcode,

736

        src: XmmMemAligned,

737

        imm: u8,

738

        dst: WritableXmm,

739

},

740

    XmmUnaryRmREvex {

741

        op: Avx512Opcode,

742

        src: XmmMem,

743

        dst: WritableXmm,

744

},

745

    XmmMovRM {

746

        op: SseOpcode,

747

        src: Xmm,

748

        dst: SyntheticAmode,

749

},

750

    XmmMovRMImm {

751

        op: SseOpcode,

752

        src: Xmm,

753

        dst: SyntheticAmode,

754

        imm: u8,

755

},

756

    XmmToGpr {

757

        op: SseOpcode,

758

        src: Xmm,

759

        dst: WritableGpr,

760

        dst_size: OperandSize,

761

},

762

    XmmToGprImm {

763

        op: SseOpcode,

764

        src: Xmm,

765

        dst: WritableGpr,

766

        imm: u8,

767

},

768

    GprToXmm {

769

        op: SseOpcode,

770

        src: GprMem,

771

        dst: WritableXmm,

772

        src_size: OperandSize,

773

},

774

    CvtUint64ToFloatSeq {

775

        dst_size: OperandSize,

776

        src: Gpr,

777

        dst: WritableXmm,

778

        tmp_gpr1: WritableGpr,

779

        tmp_gpr2: WritableGpr,

780

},

781

    CvtFloatToSintSeq {

782

        dst_size: OperandSize,

783

        src_size: OperandSize,

784

        is_saturating: bool,

785

        src: Xmm,

786

        dst: WritableGpr,

787

        tmp_gpr: WritableGpr,

788

        tmp_xmm: WritableXmm,

789

},

790

    CvtFloatToUintSeq {

791

        dst_size: OperandSize,

792

        src_size: OperandSize,

793

        is_saturating: bool,

794

        src: Xmm,

795

        dst: WritableGpr,

796

        tmp_gpr: WritableGpr,

797

        tmp_xmm: WritableXmm,

798

        tmp_xmm2: WritableXmm,

799

},

800

    XmmMinMaxSeq {

801

        size: OperandSize,

802

        is_min: bool,

803

        lhs: Xmm,

804

        rhs: Xmm,

805

        dst: WritableXmm,

806

},

807

    XmmCmpRmR {

808

        op: SseOpcode,

809

        src: XmmMemAligned,

810

        dst: Xmm,

811

},

812

    XmmRmRImm {

813

        op: SseOpcode,

814

        src1: Reg,

815

        src2: RegMem,

816

        dst: WritableReg,

817

        imm: u8,

818

        size: OperandSize,

819

},

820

    CallKnown {

821

        dest: ExternalName,

822

        info: BoxCallInfo,

823

},

824

    CallUnknown {

825

        dest: RegMem,

826

        info: BoxCallInfo,

827

},

828

    Args {

829

        args: VecArgPair,

830

},

831

    Ret {

832

        rets: VecRetPair,

833

},

834

    JmpKnown {

835

        dst: MachLabel,

836

},

837

    JmpIf {

838

        cc: CC,

839

        taken: MachLabel,

840

},

841

    JmpCond {

842

        cc: CC,

843

        taken: MachLabel,

844

        not_taken: MachLabel,

845

},

846

    JmpTableSeq {

847

        idx: Reg,

848

        tmp1: WritableReg,

849

        tmp2: WritableReg,

850

        default_target: MachLabel,

851

        targets: BoxVecMachLabel,

852

},

853

    JmpUnknown {

854

        target: RegMem,

855

},

856

    TrapIf {

857

        cc: CC,

858

        trap_code: TrapCode,

859

},

860

    TrapIfAnd {

861

        cc1: CC,

862

        cc2: CC,

863

        trap_code: TrapCode,

864

},

865

    TrapIfOr {

866

        cc1: CC,

867

        cc2: CC,

868

        trap_code: TrapCode,

869

},

870

    Hlt,

871

    Ud2 {

872

        trap_code: TrapCode,

873

},

874

    LoadExtName {

875

        dst: WritableReg,

876

        name: BoxExternalName,

877

        offset: i64,

878

},

879

    LockCmpxchg {

880

        ty: Type,

881

        replacement: Reg,

882

        expected: Reg,

883

        mem: SyntheticAmode,

884

        dst_old: WritableReg,

885

},

886

    AtomicRmwSeq {

887

        ty: Type,

888

        op: MachAtomicRmwOp,

889

        mem: SyntheticAmode,

890

        operand: Reg,

891

        temp: WritableReg,

892

        dst_old: WritableReg,

893

},

894

    Fence {

895

        kind: FenceKind,

896

},

897

    VirtualSPOffsetAdj {

898

        offset: i64,

899

},

900

    XmmUninitializedValue {

901

        dst: WritableXmm,

902

},

903

    ElfTlsGetAddr {

904

        symbol: ExternalName,

905

        dst: WritableGpr,

906

},

907

    MachOTlsGetAddr {

908

        symbol: ExternalName,

909

        dst: WritableGpr,

910

},

911

    CoffTlsGetAddr {

912

        symbol: ExternalName,

913

        dst: WritableGpr,

914

        tmp: WritableGpr,

915

},

916

    Unwind {

917

        inst: UnwindInst,

918

},

919

    DummyUse {

920

        reg: Reg,

921

},

922

923

924

/// Internal type DivSignedness: defined at src/isa/x64/inst.isle line 663.

925

#[derive(Copy, Clone, PartialEq, Eq, Debug)]

926

pub enum DivSignedness {

927

    Signed,

928

    Unsigned,

929

930

931

/// Internal type Amode: defined at src/isa/x64/inst.isle line 971.

932

#[derive(Clone, Debug)]

933

pub enum Amode {

934

    ImmReg {

935

        simm32: u32,

936

        base: Reg,

937

        flags: MemFlags,

938

},

939

    ImmRegRegShift {

940

        simm32: u32,

941

        base: Gpr,

942

        index: Gpr,

943

        shift: u8,

944

        flags: MemFlags,

945

},

946

    RipRelative {

947

        target: MachLabel,

948

},

949

950

951

/// Internal type AvxOpcode: defined at src/isa/x64/inst.isle line 1120.

952

#[derive(Copy, Clone, PartialEq, Eq, Debug)]

953

pub enum AvxOpcode {

954

    Vfmadd213ss,

955

    Vfmadd213sd,

956

    Vfmadd213ps,

957

    Vfmadd213pd,

958

    Vfmadd132ss,

959

    Vfmadd132sd,

960

    Vfmadd132ps,

961

    Vfmadd132pd,

962

    Vfnmadd213ss,

963

    Vfnmadd213sd,

964

    Vfnmadd213ps,

965

    Vfnmadd213pd,

966

    Vfnmadd132ss,

967

    Vfnmadd132sd,

968

    Vfnmadd132ps,

969

    Vfnmadd132pd,

970

    Vcmpps,

971

    Vcmppd,

972

    Vpsrlw,

973

    Vpsrld,

974

    Vpsrlq,

975

    Vpaddb,

976

    Vpaddw,

977

    Vpaddd,

978

    Vpaddq,

979

    Vpaddsb,

980

    Vpaddsw,

981

    Vpaddusb,

982

    Vpaddusw,

983

    Vpsubb,

984

    Vpsubw,

985

    Vpsubd,

986

    Vpsubq,

987

    Vpsubsb,

988

    Vpsubsw,

989

    Vpsubusb,

990

    Vpsubusw,

991

    Vpavgb,

992

    Vpavgw,

993

    Vpand,

994

    Vandps,

995

    Vandpd,

996

    Vpor,

997

    Vorps,

998

    Vorpd,

999

    Vpxor,

1000

    Vxorps,

1001

    Vxorpd,

1002

    Vpmullw,

1003

    Vpmulld,

1004

    Vpmulhw,

1005

    Vpmulhd,

1006

    Vpmulhrsw,

1007

    Vpmulhuw,

1008

    Vpmuldq,

1009

    Vpmuludq,

1010

    Vpunpckhwd,

1011

    Vpunpcklwd,

1012

    Vunpcklps,

1013

    Vandnps,

1014

    Vandnpd,

1015

    Vpandn,

1016

    Vaddps,

1017

    Vaddpd,

1018

    Vsubps,

1019

    Vsubpd,

1020

    Vmulps,

1021

    Vmulpd,

1022

    Vdivps,

1023

    Vdivpd,

1024

    Vpcmpeqb,

1025

    Vpcmpeqw,

1026

    Vpcmpeqd,

1027

    Vpcmpeqq,

1028

    Vpcmpgtb,

1029

    Vpcmpgtw,

1030

    Vpcmpgtd,

1031

    Vpcmpgtq,

1032

    Vminps,

1033

    Vminpd,

1034

    Vmaxps,

1035

    Vmaxpd,

1036

    Vblendvpd,

1037

    Vblendvps,

1038

    Vpblendvb,

1039

    Vmovlhps,

1040

    Vpmaxsb,

1041

    Vpmaxsw,

1042

    Vpmaxsd,

1043

    Vpminsb,

1044

    Vpminsw,

1045

    Vpminsd,

1046

    Vpmaxub,

1047

    Vpmaxuw,

1048

    Vpmaxud,

1049

    Vpminub,

1050

    Vpminuw,

1051

    Vpminud,

1052

    Vpunpcklbw,

1053

    Vpunpckhbw,

1054

    Vpacksswb,

1055

    Vpackssdw,

1056

    Vpackuswb,

1057

    Vpackusdw,

1058

    Vpalignr,

1059

    Vpinsrb,

1060

    Vpinsrw,

1061

    Vpinsrd,

1062

    Vpinsrq,

1063

    Vpmaddwd,

1064

    Vpmaddubsw,

1065

    Vinsertps,

1066

    Vpshufb,

1067

    Vshufps,

1068

    Vpsllw,

1069

    Vpslld,

1070

    Vpsllq,

1071

    Vpsraw,

1072

    Vpsrad,

1073

    Vpmovsxbw,

1074

    Vpmovzxbw,

1075

    Vpmovsxwd,

1076

    Vpmovzxwd,

1077

    Vpmovsxdq,

1078

    Vpmovzxdq,

1079

    Vaddss,

1080

    Vaddsd,

1081

    Vmulss,

1082

    Vmulsd,

1083

    Vsubss,

1084

    Vsubsd,

1085

    Vdivss,

1086

    Vdivsd,

1087

    Vpabsb,

1088

    Vpabsw,

1089

    Vpabsd,

1090

    Vminss,

1091

    Vminsd,

1092

    Vmaxss,

1093

    Vmaxsd,

1094

    Vsqrtps,

1095

    Vsqrtpd,

1096

    Vroundps,

1097

    Vroundpd,

1098

    Vcvtdq2pd,

1099

    Vcvtdq2ps,

1100

    Vcvtpd2ps,

1101

    Vcvtps2pd,

1102

    Vcvttpd2dq,

1103

    Vcvttps2dq,

1104

    Vphaddw,

1105

    Vphaddd,

1106

    Vpunpckhdq,

1107

    Vpunpckldq,

1108

    Vpunpckhqdq,

1109

    Vpunpcklqdq,

1110

    Vpshuflw,

1111

    Vpshufhw,

1112

    Vpshufd,

1113

    Vmovss,

1114

    Vmovsd,

1115

    Vmovups,

1116

    Vmovupd,

1117

    Vmovdqu,

1118

    Vpextrb,

1119

    Vpextrw,

1120

    Vpextrd,

1121

    Vpextrq,

1122

    Vpblendw,

1123

    Vmovddup,

1124

    Vpbroadcastb,

1125

    Vpbroadcastw,

1126

    Vpbroadcastd,

1127

    Vbroadcastss,

1128

    Vmovd,

1129

    Vmovq,

1130

    Vmovmskps,

1131

    Vmovmskpd,

1132

    Vpmovmskb,

1133

    Vcvtsi2ss,

1134

    Vcvtsi2sd,

1135

    Vcvtss2sd,

1136

    Vcvtsd2ss,

1137

    Vsqrtss,

1138

    Vsqrtsd,

1139

    Vroundss,

1140

    Vroundsd,

1141

1142

1143

/// Internal type RegisterClass: defined at src/isa/x64/inst.isle line 1585.

1144

#[derive(Clone, Debug)]

1145

pub enum RegisterClass {

1146

    Gpr { single_register: bool },

1147

    Xmm,

1148

1149

1150

/// Internal type ExtendKind: defined at src/isa/x64/inst.isle line 1726.

1151

#[derive(Copy, Clone, PartialEq, Eq, Debug)]

1152

pub enum ExtendKind {

1153

    Sign,

1154

    Zero,

1155

1156

1157

/// Internal type IcmpCondResult: defined at src/isa/x64/inst.isle line 4359.

1158

#[derive(Clone, Debug)]

1159

pub enum IcmpCondResult {

1160

    Condition { producer: ProducesFlags, cc: CC },

1161

1162

1163

/// Internal type FcmpCondResult: defined at src/isa/x64/inst.isle line 4472.

1164

#[derive(Clone, Debug)]

1165

pub enum FcmpCondResult {

1166

    Condition {

1167

        producer: ProducesFlags,

1168

        cc: CC,

1169

},

1170

    AndCondition {

1171

        producer: ProducesFlags,

1172

        cc1: CC,

1173

        cc2: CC,

1174

},

1175

    OrCondition {

1176

        producer: ProducesFlags,

1177

        cc1: CC,

1178

        cc2: CC,

1179

},

1180

1181

1182

// Generated as internal constructor for term output_reg.

1183

pub fn constructor_output_reg<C: Context>(ctx: &mut C, arg0: Reg) -> InstOutput {

1184

    let v1 = C::value_reg(ctx, arg0);

1185

    let v2 = C::output(ctx, v1);

1186

    // Rule at src/prelude_lower.isle line 55.

1187

    return v2;

1188

1189

1190

// Generated as internal constructor for term output_value.

1191

pub fn constructor_output_value<C: Context>(ctx: &mut C, arg0: Value) -> InstOutput {

1192

    let v1 = C::put_in_regs(ctx, arg0);

1193

    let v2 = C::output(ctx, v1);

1194

    // Rule at src/prelude_lower.isle line 59.

1195

    return v2;

1196

1197

1198

// Generated as internal constructor for term temp_reg.

1199

pub fn constructor_temp_reg<C: Context>(ctx: &mut C, arg0: Type) -> Reg {

1200

    let v1 = C::temp_writable_reg(ctx, arg0);

1201

    let v2 = C::writable_reg_to_reg(ctx, v1);

1202

    // Rule at src/prelude_lower.isle line 79.

1203

    return v2;

1204

1205

1206

// Generated as internal constructor for term value_regs_range.

1207

pub fn constructor_value_regs_range<C: Context>(ctx: &mut C, arg0: ValueRegs) -> Range {

1208

    let v2 = C::value_regs_len(ctx, arg0);

1209

    let v3 = C::range(ctx, 0x0, v2);

1210

    // Rule at src/prelude_lower.isle line 128.

1211

    return v3;

1212

1213

1214

// Generated as internal constructor for term lo_reg.

1215

pub fn constructor_lo_reg<C: Context>(ctx: &mut C, arg0: Value) -> Reg {

1216

    let v1 = C::put_in_regs(ctx, arg0);

1217

    let v3 = C::value_regs_get(ctx, v1, 0x0);

1218

    // Rule at src/prelude_lower.isle line 139.

1219

    return v3;

1220

1221

1222

// Generated as internal constructor for term emit_side_effect.

1223

pub fn constructor_emit_side_effect<C: Context>(ctx: &mut C, arg0: &SideEffectNoResult) -> Unit {

1224

    match arg0 {

1225

        &SideEffectNoResult::Inst { inst: ref v1 } => {

1226

            let v2 = C::emit(ctx, v1);

1227

            // Rule at src/prelude_lower.isle line 292.

1228

            return v2;

1229

1230

        &SideEffectNoResult::Inst2 {

1231

            inst1: ref v3,

1232

            inst2: ref v4,

1233

        } => {

1234

            let v5 = C::emit(ctx, v3);

1235

            let v6 = C::emit(ctx, v4);

1236

            // Rule at src/prelude_lower.isle line 294.

1237

            return v6;

1238

1239

        &SideEffectNoResult::Inst3 {

1240

            inst1: ref v7,

1241

            inst2: ref v8,

1242

            inst3: ref v9,

1243

        } => {

1244

            let v10 = C::emit(ctx, v7);

1245

            let v11 = C::emit(ctx, v8);

1246

            let v12 = C::emit(ctx, v9);

1247

            // Rule at src/prelude_lower.isle line 297.

1248

            return v12;

1249

1250

        _ => {}

1251

1252

    unreachable!(

1253

        "no rule matched for term {} at {}; should it be partial?",

1254

        "emit_side_effect", "src/prelude_lower.isle line 291"

1255

1256

1257

1258

// Generated as internal constructor for term side_effect.

1259

pub fn constructor_side_effect<C: Context>(ctx: &mut C, arg0: &SideEffectNoResult) -> InstOutput {

1260

    let v1 = constructor_emit_side_effect(ctx, arg0);

1261

    let v2 = C::output_none(ctx);

1262

    // Rule at src/prelude_lower.isle line 305.

1263

    return v2;

1264

1265

1266

// Generated as internal constructor for term side_effect_concat.

1267

pub fn constructor_side_effect_concat<C: Context>(

1268

    ctx: &mut C,

1269

    arg0: &SideEffectNoResult,

1270

    arg1: &SideEffectNoResult,

1271

) -> SideEffectNoResult {

1272

    match arg0 {

1273

        &SideEffectNoResult::Inst { inst: ref v1 } => {

1274

            match arg1 {

1275

                &SideEffectNoResult::Inst { inst: ref v3 } => {

1276

                    let v4 = SideEffectNoResult::Inst2 {

1277

                        inst1: v1.clone(),

1278

                        inst2: v3.clone(),

1279

};

1280

                    // Rule at src/prelude_lower.isle line 310.

1281

                    return v4;

1282

1283

                &SideEffectNoResult::Inst2 {

1284

                    inst1: ref v5,

1285

                    inst2: ref v6,

1286

                } => {

1287

                    let v7 = SideEffectNoResult::Inst3 {

1288

                        inst1: v1.clone(),

1289

                        inst2: v5.clone(),

1290

                        inst3: v6.clone(),

1291

};

1292

                    // Rule at src/prelude_lower.isle line 312.

1293

                    return v7;

1294

1295

                _ => {}

1296

1297

1298

        &SideEffectNoResult::Inst2 {

1299

            inst1: ref v8,

1300

            inst2: ref v9,

1301

        } => {

1302

            if let &SideEffectNoResult::Inst { inst: ref v3 } = arg1 {

1303

                let v10 = SideEffectNoResult::Inst3 {

1304

                    inst1: v8.clone(),

1305

                    inst2: v9.clone(),

1306

                    inst3: v3.clone(),

1307

};

1308

                // Rule at src/prelude_lower.isle line 314.

1309

                return v10;

1310

1311

1312

        _ => {}

1313

1314

    unreachable!(

1315

        "no rule matched for term {} at {}; should it be partial?",

1316

        "side_effect_concat", "src/prelude_lower.isle line 309"

1317

1318

1319

1320

// Generated as internal constructor for term produces_flags_append.

1321

pub fn constructor_produces_flags_append<C: Context>(

1322

    ctx: &mut C,

1323

    arg0: &ProducesFlags,

1324

    arg1: &MInst,

1325

) -> ProducesFlags {

1326

    if let &ProducesFlags::ProducesFlagsSideEffect { inst: ref v1 } = arg0 {

1327

        let v3 = ProducesFlags::ProducesFlagsTwiceSideEffect {

1328

            inst1: v1.clone(),

1329

            inst2: arg1.clone(),

1330

};

1331

        // Rule at src/prelude_lower.isle line 339.

1332

        return v3;

1333

1334

    unreachable!(

1335

        "no rule matched for term {} at {}; should it be partial?",

1336

        "produces_flags_append", "src/prelude_lower.isle line 338"

1337

1338

1339

1340

// Generated as internal constructor for term produces_flags_get_reg.

1341

pub fn constructor_produces_flags_get_reg<C: Context>(ctx: &mut C, arg0: &ProducesFlags) -> Reg {

1342

    match arg0 {

1343

        &ProducesFlags::ProducesFlagsReturnsReg {

1344

            inst: ref v1,

1345

            result: v2,

1346

        } => {

1347

            // Rule at src/prelude_lower.isle line 364.

1348

            return v2;

1349

1350

        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {

1351

            inst: ref v3,

1352

            result: v4,

1353

        } => {

1354

            // Rule at src/prelude_lower.isle line 365.

1355

            return v4;

1356

1357

        _ => {}

1358

1359

    unreachable!(

1360

        "no rule matched for term {} at {}; should it be partial?",

1361

        "produces_flags_get_reg", "src/prelude_lower.isle line 363"

1362

1363

1364

1365

// Generated as internal constructor for term produces_flags_ignore.

1366

pub fn constructor_produces_flags_ignore<C: Context>(

1367

    ctx: &mut C,

1368

    arg0: &ProducesFlags,

1369

) -> ProducesFlags {

1370

    match arg0 {

1371

        &ProducesFlags::ProducesFlagsReturnsReg {

1372

            inst: ref v1,

1373

            result: v2,

1374

        } => {

1375

            let v3 = ProducesFlags::ProducesFlagsSideEffect { inst: v1.clone() };

1376

            // Rule at src/prelude_lower.isle line 370.

1377

            return v3;

1378

1379

        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {

1380

            inst: ref v4,

1381

            result: v5,

1382

        } => {

1383

            let v6 = ProducesFlags::ProducesFlagsSideEffect { inst: v4.clone() };

1384

            // Rule at src/prelude_lower.isle line 372.

1385

            return v6;

1386

1387

        _ => {}

1388

1389

    unreachable!(

1390

        "no rule matched for term {} at {}; should it be partial?",

1391

        "produces_flags_ignore", "src/prelude_lower.isle line 369"

1392

1393

1394

1395

// Generated as internal constructor for term consumes_flags_concat.

1396

pub fn constructor_consumes_flags_concat<C: Context>(

1397

    ctx: &mut C,

1398

    arg0: &ConsumesFlags,

1399

    arg1: &ConsumesFlags,

1400

) -> ConsumesFlags {

1401

    match arg0 {

1402

        &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v8 } => {

1403

            if let &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v9 } = arg1 {

1404

                let v10 = ConsumesFlags::ConsumesFlagsSideEffect2 {

1405

                    inst1: v8.clone(),

1406

                    inst2: v9.clone(),

1407

};

1408

                // Rule at src/prelude_lower.isle line 385.

1409

                return v10;

1410

1411

1412

        &ConsumesFlags::ConsumesFlagsReturnsReg {

1413

            inst: ref v1,

1414

            result: v2,

1415

        } => {

1416

            if let &ConsumesFlags::ConsumesFlagsReturnsReg {

1417

                inst: ref v4,

1418

                result: v5,

1419

            } = arg1

1420

1421

                let v6 = C::value_regs(ctx, v2, v5);

1422

                let v7 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

1423

                    inst1: v1.clone(),

1424

                    inst2: v4.clone(),

1425

                    result: v6,

1426

};

1427

                // Rule at src/prelude_lower.isle line 379.

1428

                return v7;

1429

1430

1431

        _ => {}

1432

1433

    unreachable!(

1434

        "no rule matched for term {} at {}; should it be partial?",

1435

        "consumes_flags_concat", "src/prelude_lower.isle line 378"

1436

1437

1438

1439

// Generated as internal constructor for term with_flags.

1440

pub fn constructor_with_flags<C: Context>(

1441

    ctx: &mut C,

1442

    arg0: &ProducesFlags,

1443

    arg1: &ConsumesFlags,

1444

) -> ValueRegs {

1445

    match arg0 {

1446

        &ProducesFlags::ProducesFlagsSideEffect { inst: ref v12 } => {

1447

            match arg1 {

1448

                &ConsumesFlags::ConsumesFlagsReturnsReg {

1449

                    inst: ref v13,

1450

                    result: v14,

1451

                } => {

1452

                    let v15 = C::emit(ctx, v12);

1453

                    let v16 = C::emit(ctx, v13);

1454

                    let v17 = C::value_reg(ctx, v14);

1455

                    // Rule at src/prelude_lower.isle line 416.

1456

                    return v17;

1457

1458

                &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

1459

                    inst1: ref v18,

1460

                    inst2: ref v19,

1461

                    result: v20,

1462

                } => {

1463

                    let v15 = C::emit(ctx, v12);

1464

                    let v21 = C::emit(ctx, v18);

1465

                    let v22 = C::emit(ctx, v19);

1466

                    // Rule at src/prelude_lower.isle line 422.

1467

                    return v20;

1468

1469

                &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {

1470

                    inst1: ref v23,

1471

                    inst2: ref v24,

1472

                    inst3: ref v25,

1473

                    inst4: ref v26,

1474

                    result: v27,

1475

                } => {

1476

                    let v15 = C::emit(ctx, v12);

1477

                    let v28 = C::emit(ctx, v23);

1478

                    let v29 = C::emit(ctx, v24);

1479

                    let v30 = C::emit(ctx, v25);

1480

                    let v31 = C::emit(ctx, v26);

1481

                    // Rule at src/prelude_lower.isle line 434.

1482

                    return v27;

1483

1484

                _ => {}

1485

1486

1487

        &ProducesFlags::ProducesFlagsTwiceSideEffect {

1488

            inst1: ref v32,

1489

            inst2: ref v33,

1490

        } => {

1491

            match arg1 {

1492

                &ConsumesFlags::ConsumesFlagsReturnsReg {

1493

                    inst: ref v13,

1494

                    result: v14,

1495

                } => {

1496

                    let v34 = C::emit(ctx, v32);

1497

                    let v35 = C::emit(ctx, v33);

1498

                    let v36 = C::emit(ctx, v13);

1499

                    let v37 = C::value_reg(ctx, v14);

1500

                    // Rule at src/prelude_lower.isle line 450.

1501

                    return v37;

1502

1503

                &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

1504

                    inst1: ref v18,

1505

                    inst2: ref v19,

1506

                    result: v20,

1507

                } => {

1508

                    let v34 = C::emit(ctx, v32);

1509

                    let v35 = C::emit(ctx, v33);

1510

                    let v38 = C::emit(ctx, v18);

1511

                    let v39 = C::emit(ctx, v19);

1512

                    // Rule at src/prelude_lower.isle line 457.

1513

                    return v20;

1514

1515

                &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {

1516

                    inst1: ref v23,

1517

                    inst2: ref v24,

1518

                    inst3: ref v25,

1519

                    inst4: ref v26,

1520

                    result: v27,

1521

                } => {

1522

                    let v34 = C::emit(ctx, v32);

1523

                    let v35 = C::emit(ctx, v33);

1524

                    let v40 = C::emit(ctx, v23);

1525

                    let v41 = C::emit(ctx, v24);

1526

                    let v42 = C::emit(ctx, v25);

1527

                    let v43 = C::emit(ctx, v26);

1528

                    // Rule at src/prelude_lower.isle line 470.

1529

                    return v27;

1530

1531

                _ => {}

1532

1533

1534

        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {

1535

            inst: ref v1,

1536

            result: v2,

1537

        } => {

1538

            match arg1 {

1539

                &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v9 } => {

1540

                    let v6 = C::emit(ctx, v1);

1541

                    let v10 = C::emit(ctx, v9);

1542

                    let v11 = C::value_reg(ctx, v2);

1543

                    // Rule at src/prelude_lower.isle line 410.

1544

                    return v11;

1545

1546

                &ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {

1547

                    inst: ref v4,

1548

                    result: v5,

1549

                } => {

1550

                    let v6 = C::emit(ctx, v1);

1551

                    let v7 = C::emit(ctx, v4);

1552

                    let v8 = C::value_regs(ctx, v2, v5);

1553

                    // Rule at src/prelude_lower.isle line 402.

1554

                    return v8;

1555

1556

                _ => {}

1557

1558

1559

        _ => {}

1560

1561

    unreachable!(

1562

        "no rule matched for term {} at {}; should it be partial?",

1563

        "with_flags", "src/prelude_lower.isle line 400"

1564

1565

1566

1567

// Generated as internal constructor for term with_flags_reg.

1568

pub fn constructor_with_flags_reg<C: Context>(

1569

    ctx: &mut C,

1570

    arg0: &ProducesFlags,

1571

    arg1: &ConsumesFlags,

1572

) -> Reg {

1573

    let v2 = constructor_with_flags(ctx, arg0, arg1);

1574

    let v4 = C::value_regs_get(ctx, v2, 0x0);

1575

    // Rule at src/prelude_lower.isle line 488.

1576

    return v4;

1577

1578

1579

// Generated as internal constructor for term flags_to_producesflags.

1580

pub fn constructor_flags_to_producesflags<C: Context>(ctx: &mut C, arg0: Value) -> ProducesFlags {

1581

    let v1 = C::mark_value_used(ctx, arg0);

1582

    // Rule at src/prelude_lower.isle line 495.

1583

    return ProducesFlags::AlreadyExistingFlags;

1584

1585

1586

// Generated as internal constructor for term with_flags_side_effect.

1587

pub fn constructor_with_flags_side_effect<C: Context>(

1588

    ctx: &mut C,

1589

    arg0: &ProducesFlags,

1590

    arg1: &ConsumesFlags,

1591

) -> SideEffectNoResult {

1592

    match arg0 {

1593

        &ProducesFlags::AlreadyExistingFlags => {

1594

            match arg1 {

1595

                &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v2 } => {

1596

                    let v3 = SideEffectNoResult::Inst { inst: v2.clone() };

1597

                    // Rule at src/prelude_lower.isle line 506.

1598

                    return v3;

1599

1600

                &ConsumesFlags::ConsumesFlagsSideEffect2 {

1601

                    inst1: ref v4,

1602

                    inst2: ref v5,

1603

                } => {

1604

                    let v6 = SideEffectNoResult::Inst2 {

1605

                        inst1: v4.clone(),

1606

                        inst2: v5.clone(),

1607

};

1608

                    // Rule at src/prelude_lower.isle line 511.

1609

                    return v6;

1610

1611

                _ => {}

1612

1613

1614

        &ProducesFlags::ProducesFlagsSideEffect { inst: ref v7 } => {

1615

            match arg1 {

1616

                &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v2 } => {

1617

                    let v8 = SideEffectNoResult::Inst2 {

1618

                        inst1: v7.clone(),

1619

                        inst2: v2.clone(),

1620

};

1621

                    // Rule at src/prelude_lower.isle line 516.

1622

                    return v8;

1623

1624

                &ConsumesFlags::ConsumesFlagsSideEffect2 {

1625

                    inst1: ref v4,

1626

                    inst2: ref v5,

1627

                } => {

1628

                    let v9 = SideEffectNoResult::Inst3 {

1629

                        inst1: v7.clone(),

1630

                        inst2: v4.clone(),

1631

                        inst3: v5.clone(),

1632

};

1633

                    // Rule at src/prelude_lower.isle line 521.

1634

                    return v9;

1635

1636

                _ => {}

1637

1638

1639

        &ProducesFlags::ProducesFlagsTwiceSideEffect {

1640

            inst1: ref v10,

1641

            inst2: ref v11,

1642

        } => {

1643

            if let &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v2 } = arg1 {

1644

                let v12 = SideEffectNoResult::Inst3 {

1645

                    inst1: v10.clone(),

1646

                    inst2: v11.clone(),

1647

                    inst3: v2.clone(),

1648

};

1649

                // Rule at src/prelude_lower.isle line 526.

1650

                return v12;

1651

1652

1653

        _ => {}

1654

1655

    unreachable!(

1656

        "no rule matched for term {} at {}; should it be partial?",

1657

        "with_flags_side_effect", "src/prelude_lower.isle line 504"

1658

1659

1660

1661

// Generated as internal constructor for term lower_return.

1662

pub fn constructor_lower_return<C: Context>(

1663

    ctx: &mut C,

1664

    arg0: Range,

1665

    arg1: ValueSlice,

1666

) -> InstOutput {

1667

    let v2 = C::gen_return(ctx, arg1);

1668

    let v3 = C::output_none(ctx);

1669

    // Rule at src/prelude_lower.isle line 715.

1670

    return v3;

1671

1672

1673

// Generated as internal constructor for term operand_size_bits.

1674

pub fn constructor_operand_size_bits<C: Context>(ctx: &mut C, arg0: &OperandSize) -> u16 {

1675

    match arg0 {

1676

        &OperandSize::Size8 => {

1677

            // Rule at src/isa/x64/inst.isle line 704.

1678

            return 0x8;

1679

1680

        &OperandSize::Size16 => {

1681

            // Rule at src/isa/x64/inst.isle line 705.

1682

            return 0x10;

1683

1684

        &OperandSize::Size32 => {

1685

            // Rule at src/isa/x64/inst.isle line 706.

1686

            return 0x20;

1687

1688

        &OperandSize::Size64 => {

1689

            // Rule at src/isa/x64/inst.isle line 707.

1690

            return 0x40;

1691

1692

        _ => {}

1693

1694

    unreachable!(

1695

        "no rule matched for term {} at {}; should it be partial?",

1696

        "operand_size_bits", "src/isa/x64/inst.isle line 703"

1697

1698

1699

1700

// Generated as internal constructor for term reg_mem_to_reg_mem_imm.

1701

pub fn constructor_reg_mem_to_reg_mem_imm<C: Context>(ctx: &mut C, arg0: &RegMem) -> RegMemImm {

1702

    match arg0 {

1703

        &RegMem::Reg { reg: v1 } => {

1704

            let v2 = RegMemImm::Reg { reg: v1 };

1705

            // Rule at src/isa/x64/inst.isle line 945.

1706

            return v2;

1707

1708

        &RegMem::Mem { addr: ref v3 } => {

1709

            let v4 = RegMemImm::Mem { addr: v3.clone() };

1710

            // Rule at src/isa/x64/inst.isle line 947.

1711

            return v4;

1712

1713

        _ => {}

1714

1715

    unreachable!(

1716

        "no rule matched for term {} at {}; should it be partial?",

1717

        "reg_mem_to_reg_mem_imm", "src/isa/x64/inst.isle line 944"

1718

1719

1720

1721

// Generated as internal constructor for term to_amode.

1722

pub fn constructor_to_amode<C: Context>(

1723

    ctx: &mut C,

1724

    arg0: MemFlags,

1725

    arg1: Value,

1726

    arg2: Offset32,

1727

) -> Amode {

1728

    let v6 = C::def_inst(ctx, arg1);

1729

    if let Some(v7) = v6 {

1730

        let v8 = &C::inst_data(ctx, v7);

1731

        if let &InstructionData::Binary {

1732

            opcode: ref v9,

1733

            args: ref v10,

1734

        } = v8

1735

1736

            if let &Opcode::Iadd = v9 {

1737

                let v11 = C::unpack_value_array_2(ctx, v10);

1738

                let v14 = &constructor_to_amode_add(ctx, arg0, v11.0, v11.1, arg2);

1739

                // Rule at src/isa/x64/inst.isle line 1009.

1740

                return v14.clone();

1741

1742

1743

1744

    let v4 = C::put_in_reg(ctx, arg1);

1745

    let v3 = C::offset32_to_u32(ctx, arg2);

1746

    let v5 = Amode::ImmReg {

1747

        simm32: v3,

1748

        base: v4,

1749

        flags: arg0,

1750

};

1751

    // Rule at src/isa/x64/inst.isle line 1004.

1752

    return v5;

1753

1754

1755

// Generated as internal constructor for term to_amode_add.

1756

pub fn constructor_to_amode_add<C: Context>(

1757

    ctx: &mut C,

1758

    arg0: MemFlags,

1759

    arg1: Value,

1760

    arg2: Value,

1761

    arg3: Offset32,

1762

) -> Amode {

1763

    let v30 = C::def_inst(ctx, arg1);

1764

    if let Some(v31) = v30 {

1765

        let v32 = &C::inst_data(ctx, v31);

1766

        if let &InstructionData::UnaryImm {

1767

            opcode: ref v71,

1768

            imm: v72,

1769

        } = v32

1770

1771

            if let &Opcode::Iconst = v71 {

1772

                let v73 = C::simm32(ctx, v72);

1773

                if let Some(v74) = v73 {

1774

                    let v4 = C::offset32_to_u32(ctx, arg3);

1775

                    let v75 = C::s32_add_fallible(ctx, v4, v74);

1776

                    if let Some(v76) = v75 {

1777

                        let v77 = C::u32_to_offset32(ctx, v76);

1778

                        let v78 = &constructor_to_amode(ctx, arg0, arg2, v77);

1779

                        // Rule at src/isa/x64/inst.isle line 1048.

1780

                        return v78.clone();

1781

1782

1783

1784

1785

1786

    let v9 = C::def_inst(ctx, arg2);

1787

    if let Some(v10) = v9 {

1788

        let v11 = &C::inst_data(ctx, v10);

1789

        match v11 {

1790

            &InstructionData::Binary {

1791

                opcode: ref v12,

1792

                args: ref v13,

1793

            } => {

1794

                if let &Opcode::Iadd = v12 {

1795

                    let v14 = C::unpack_value_array_2(ctx, v13);

1796

                    let v17 = C::def_inst(ctx, v14.1);

1797

                    if let Some(v18) = v17 {

1798

                        let v19 = &C::inst_data(ctx, v18);

1799

                        if let &InstructionData::UnaryImm {

1800

                            opcode: ref v20,

1801

                            imm: v21,

1802

                        } = v19

1803

1804

                            if let &Opcode::Iconst = v20 {

1805

                                let v57 = C::simm32(ctx, v21);

1806

                                if let Some(v58) = v57 {

1807

                                    let v4 = C::offset32_to_u32(ctx, arg3);

1808

                                    let v59 = C::s32_add_fallible(ctx, v4, v58);

1809

                                    if let Some(v60) = v59 {

1810

                                        let v61 = C::u32_to_offset32(ctx, v60);

1811

                                        let v62 =

1812

                                            &constructor_to_amode_add(ctx, arg0, arg1, v14.0, v61);

1813

                                        // Rule at src/isa/x64/inst.isle line 1042.

1814

                                        return v62.clone();

1815

1816

1817

1818

1819

1820

1821

1822

            &InstructionData::UnaryImm {

1823

                opcode: ref v63,

1824

                imm: v64,

1825

            } => {

1826

                if let &Opcode::Iconst = v63 {

1827

                    let v65 = C::simm32(ctx, v64);

1828

                    if let Some(v66) = v65 {

1829

                        let v4 = C::offset32_to_u32(ctx, arg3);

1830

                        let v67 = C::s32_add_fallible(ctx, v4, v66);

1831

                        if let Some(v68) = v67 {

1832

                            let v69 = C::u32_to_offset32(ctx, v68);

1833

                            let v70 = &constructor_to_amode(ctx, arg0, arg1, v69);

1834

                            // Rule at src/isa/x64/inst.isle line 1045.

1835

                            return v70.clone();

1836

1837

1838

1839

1840

            _ => {}

1841

1842

1843

    if let Some(v31) = v30 {

1844

        let v32 = &C::inst_data(ctx, v31);

1845

        if let &InstructionData::Binary {

1846

            opcode: ref v33,

1847

            args: ref v34,

1848

        } = v32

1849

1850

            match v33 {

1851

                &Opcode::Iadd => {

1852

                    let v35 = C::unpack_value_array_2(ctx, v34);

1853

                    let v38 = C::def_inst(ctx, v35.1);

1854

                    if let Some(v39) = v38 {

1855

                        let v40 = &C::inst_data(ctx, v39);

1856

                        if let &InstructionData::UnaryImm {

1857

                            opcode: ref v41,

1858

                            imm: v42,

1859

                        } = v40

1860

1861

                            if let &Opcode::Iconst = v41 {

1862

                                let v51 = C::simm32(ctx, v42);

1863

                                if let Some(v52) = v51 {

1864

                                    let v4 = C::offset32_to_u32(ctx, arg3);

1865

                                    let v53 = C::s32_add_fallible(ctx, v4, v52);

1866

                                    if let Some(v54) = v53 {

1867

                                        let v55 = C::u32_to_offset32(ctx, v54);

1868

                                        let v56 =

1869

                                            &constructor_to_amode_add(ctx, arg0, v35.0, arg2, v55);

1870

                                        // Rule at src/isa/x64/inst.isle line 1039.

1871

                                        return v56.clone();

1872

1873

1874

1875

1876

1877

1878

                &Opcode::Ishl => {

1879

                    let v35 = C::unpack_value_array_2(ctx, v34);

1880

                    let v38 = C::def_inst(ctx, v35.1);

1881

                    if let Some(v39) = v38 {

1882

                        let v40 = &C::inst_data(ctx, v39);

1883

                        if let &InstructionData::UnaryImm {

1884

                            opcode: ref v41,

1885

                            imm: v42,

1886

                        } = v40

1887

1888

                            if let &Opcode::Iconst = v41 {

1889

                                let v43 = C::uimm8(ctx, v42);

1890

                                if let Some(v44) = v43 {

1891

                                    let v45 = C::u8_as_u32(ctx, v44);

1892

                                    let v46 = C::u32_lteq(ctx, v45, 0x3);

1893

                                    if let Some(v47) = v46 {

1894

                                        let v48 = constructor_put_in_gpr(ctx, arg2);

1895

                                        let v49 = constructor_put_in_gpr(ctx, v35.0);

1896

                                        let v4 = C::offset32_to_u32(ctx, arg3);

1897

                                        let v50 = Amode::ImmRegRegShift {

1898

                                            simm32: v4,

1899

                                            base: v48,

1900

                                            index: v49,

1901

                                            shift: v44,

1902

                                            flags: arg0,

1903

};

1904

                                        // Rule at src/isa/x64/inst.isle line 1026.

1905

                                        return v50;

1906

1907

1908

1909

1910

1911

1912

                _ => {}

1913

1914

1915

1916

    if let Some(v10) = v9 {

1917

        let v11 = &C::inst_data(ctx, v10);

1918

        if let &InstructionData::Binary {

1919

            opcode: ref v12,

1920

            args: ref v13,

1921

        } = v11

1922

1923

            if let &Opcode::Ishl = v12 {

1924

                let v14 = C::unpack_value_array_2(ctx, v13);

1925

                let v17 = C::def_inst(ctx, v14.1);

1926

                if let Some(v18) = v17 {

1927

                    let v19 = &C::inst_data(ctx, v18);

1928

                    if let &InstructionData::UnaryImm {

1929

                        opcode: ref v20,

1930

                        imm: v21,

1931

                    } = v19

1932

1933

                        if let &Opcode::Iconst = v20 {

1934

                            let v22 = C::uimm8(ctx, v21);

1935

                            if let Some(v23) = v22 {

1936

                                let v24 = C::u8_as_u32(ctx, v23);

1937

                                let v26 = C::u32_lteq(ctx, v24, 0x3);

1938

                                if let Some(v27) = v26 {

1939

                                    let v5 = constructor_put_in_gpr(ctx, arg1);

1940

                                    let v28 = constructor_put_in_gpr(ctx, v14.0);

1941

                                    let v4 = C::offset32_to_u32(ctx, arg3);

1942

                                    let v29 = Amode::ImmRegRegShift {

1943

                                        simm32: v4,

1944

                                        base: v5,

1945

                                        index: v28,

1946

                                        shift: v23,

1947

                                        flags: arg0,

1948

};

1949

                                    // Rule at src/isa/x64/inst.isle line 1023.

1950

                                    return v29;

1951

1952

1953

1954

1955

1956

1957

1958

1959

    let v5 = constructor_put_in_gpr(ctx, arg1);

1960

    let v6 = constructor_put_in_gpr(ctx, arg2);

1961

    let v4 = C::offset32_to_u32(ctx, arg3);

1962

    let v8 = Amode::ImmRegRegShift {

1963

        simm32: v4,

1964

        base: v5,

1965

        index: v6,

1966

        shift: 0x0,

1967

        flags: arg0,

1968

};

1969

    // Rule at src/isa/x64/inst.isle line 1018.

1970

    return v8;

1971

1972

1973

// Generated as internal constructor for term put_masked_in_imm8_gpr.

1974

pub fn constructor_put_masked_in_imm8_gpr<C: Context>(

1975

    ctx: &mut C,

1976

    arg0: Value,

1977

    arg1: Type,

1978

) -> Imm8Gpr {

1979

    let v1 = C::def_inst(ctx, arg0);

1980

    if let Some(v2) = v1 {

1981

        let v3 = &C::inst_data(ctx, v2);

1982

        if let &InstructionData::UnaryImm {

1983

            opcode: ref v4,

1984

            imm: v5,

1985

        } = v3

1986

1987

            if let &Opcode::Iconst = v4 {

1988

                let v6 = C::u64_from_imm64(ctx, v5);

1989

                let v8 = &C::const_to_type_masked_imm8(ctx, v6, arg1);

1990

                // Rule at src/isa/x64/inst.isle line 1084.

1991

                return v8.clone();

1992

1993

1994

1995

    let v9 = C::fits_in_16(ctx, arg1);

1996

    if let Some(v10) = v9 {

1997

        let v12 = C::put_in_regs(ctx, arg0);

1998

        let v14 = constructor_value_regs_get_gpr(ctx, v12, 0x0);

1999

        let v15 = C::shift_mask(ctx, v10);

2000

        let v16 = RegMemImm::Imm { simm32: v15 };

2001

        let v17 = &C::gpr_mem_imm_new(ctx, &v16);

2002

        let v18 = constructor_x64_and(ctx, I64, v14, v17);

2003

        let v19 = &C::gpr_to_imm8_gpr(ctx, v18);

2004

        // Rule at src/isa/x64/inst.isle line 1086.

2005

        return v19.clone();

2006

2007

    let v12 = C::put_in_regs(ctx, arg0);

2008

    let v14 = constructor_value_regs_get_gpr(ctx, v12, 0x0);

2009

    let v20 = &C::gpr_to_imm8_gpr(ctx, v14);

2010

    // Rule at src/isa/x64/inst.isle line 1088.

2011

    return v20.clone();

2012

2013

2014

// Generated as internal constructor for term reg_to_gpr_mem_imm.

2015

pub fn constructor_reg_to_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Reg) -> GprMemImm {

2016

    let v1 = C::gpr_new(ctx, arg0);

2017

    let v2 = &C::gpr_to_gpr_mem_imm(ctx, v1);

2018

    // Rule at src/isa/x64/inst.isle line 1493.

2019

    return v2.clone();

2020

2021

2022

// Generated as internal constructor for term put_in_gpr.

2023

pub fn constructor_put_in_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Gpr {

2024

    let v1 = C::put_in_reg(ctx, arg0);

2025

    let v2 = C::gpr_new(ctx, v1);

2026

    // Rule at src/isa/x64/inst.isle line 1500.

2027

    return v2;

2028

2029

2030

// Generated as internal constructor for term put_in_gpr_mem.

2031

pub fn constructor_put_in_gpr_mem<C: Context>(ctx: &mut C, arg0: Value) -> GprMem {

2032

    let v1 = &C::put_in_reg_mem(ctx, arg0);

2033

    let v2 = &C::reg_mem_to_gpr_mem(ctx, v1);

2034

    // Rule at src/isa/x64/inst.isle line 1507.

2035

    return v2.clone();

2036

2037

2038

// Generated as internal constructor for term put_in_gpr_mem_imm.

2039

pub fn constructor_put_in_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Value) -> GprMemImm {

2040

    let v1 = &C::put_in_reg_mem_imm(ctx, arg0);

2041

    let v2 = &C::gpr_mem_imm_new(ctx, v1);

2042

    // Rule at src/isa/x64/inst.isle line 1514.

2043

    return v2.clone();

2044

2045

2046

// Generated as internal constructor for term put_in_xmm.

2047

pub fn constructor_put_in_xmm<C: Context>(ctx: &mut C, arg0: Value) -> Xmm {

2048

    let v1 = C::put_in_reg(ctx, arg0);

2049

    let v2 = C::xmm_new(ctx, v1);

2050

    // Rule at src/isa/x64/inst.isle line 1521.

2051

    return v2;

2052

2053

2054

// Generated as internal constructor for term output_gpr.

2055

pub fn constructor_output_gpr<C: Context>(ctx: &mut C, arg0: Gpr) -> InstOutput {

2056

    let v1 = C::gpr_to_reg(ctx, arg0);

2057

    let v2 = constructor_output_reg(ctx, v1);

2058

    // Rule at src/isa/x64/inst.isle line 1538.

2059

    return v2;

2060

2061

2062

// Generated as internal constructor for term value_gprs.

2063

pub fn constructor_value_gprs<C: Context>(ctx: &mut C, arg0: Gpr, arg1: Gpr) -> ValueRegs {

2064

    let v2 = C::gpr_to_reg(ctx, arg0);

2065

    let v3 = C::gpr_to_reg(ctx, arg1);

2066

    let v4 = C::value_regs(ctx, v2, v3);

2067

    // Rule at src/isa/x64/inst.isle line 1543.

2068

    return v4;

2069

2070

2071

// Generated as internal constructor for term output_xmm.

2072

pub fn constructor_output_xmm<C: Context>(ctx: &mut C, arg0: Xmm) -> InstOutput {

2073

    let v1 = C::xmm_to_reg(ctx, arg0);

2074

    let v2 = constructor_output_reg(ctx, v1);

2075

    // Rule at src/isa/x64/inst.isle line 1548.

2076

    return v2;

2077

2078

2079

// Generated as internal constructor for term value_regs_get_gpr.

2080

pub fn constructor_value_regs_get_gpr<C: Context>(

2081

    ctx: &mut C,

2082

    arg0: ValueRegs,

2083

    arg1: usize,

2084

) -> Gpr {

2085

    let v2 = C::value_regs_get(ctx, arg0, arg1);

2086

    let v3 = C::gpr_new(ctx, v2);

2087

    // Rule at src/isa/x64/inst.isle line 1555.

2088

    return v3;

2089

2090

2091

// Generated as internal constructor for term lo_gpr.

2092

pub fn constructor_lo_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Gpr {

2093

    let v1 = constructor_lo_reg(ctx, arg0);

2094

    let v2 = C::gpr_new(ctx, v1);

2095

    // Rule at src/isa/x64/inst.isle line 1568.

2096

    return v2;

2097

2098

2099

// Generated as internal constructor for term sink_load_to_gpr_mem_imm.

2100

pub fn constructor_sink_load_to_gpr_mem_imm<C: Context>(

2101

    ctx: &mut C,

2102

    arg0: &SinkableLoad,

2103

) -> GprMemImm {

2104

    let v1 = &constructor_sink_load_to_reg_mem_imm(ctx, arg0);

2105

    let v2 = &C::gpr_mem_imm_new(ctx, v1);

2106

    // Rule at src/isa/x64/inst.isle line 1703.

2107

    return v2.clone();

2108

2109

2110

// Generated as internal constructor for term sink_load_to_xmm_mem.

2111

pub fn constructor_sink_load_to_xmm_mem<C: Context>(ctx: &mut C, arg0: &SinkableLoad) -> XmmMem {

2112

    let v1 = &constructor_sink_load_to_reg_mem(ctx, arg0);

2113

    let v2 = &C::reg_mem_to_xmm_mem(ctx, v1);

2114

    // Rule at src/isa/x64/inst.isle line 1707.

2115

    return v2.clone();

2116

2117

2118

// Generated as internal constructor for term sink_load_to_reg_mem.

2119

pub fn constructor_sink_load_to_reg_mem<C: Context>(ctx: &mut C, arg0: &SinkableLoad) -> RegMem {

2120

    let v1 = &C::sink_load(ctx, arg0);

2121

    let v2 = RegMem::Mem { addr: v1.clone() };

2122

    // Rule at src/isa/x64/inst.isle line 1711.

2123

    return v2;

2124

2125

2126

// Generated as internal constructor for term sink_load_to_gpr_mem.

2127

pub fn constructor_sink_load_to_gpr_mem<C: Context>(ctx: &mut C, arg0: &SinkableLoad) -> GprMem {

2128

    let v1 = &C::sink_load(ctx, arg0);

2129

    let v2 = RegMem::Mem { addr: v1.clone() };

2130

    let v3 = &C::reg_mem_to_gpr_mem(ctx, &v2);

2131

    // Rule at src/isa/x64/inst.isle line 1714.

2132

    return v3.clone();

2133

2134

2135

// Generated as internal constructor for term sink_load_to_reg_mem_imm.

2136

pub fn constructor_sink_load_to_reg_mem_imm<C: Context>(

2137

    ctx: &mut C,

2138

    arg0: &SinkableLoad,

2139

) -> RegMemImm {

2140

    let v1 = &C::sink_load(ctx, arg0);

2141

    let v2 = RegMemImm::Mem { addr: v1.clone() };

2142

    // Rule at src/isa/x64/inst.isle line 1717.

2143

    return v2;

2144

2145

2146

// Generated as internal constructor for term extend_to_gpr.

2147

pub fn constructor_extend_to_gpr<C: Context>(

2148

    ctx: &mut C,

2149

    arg0: Value,

2150

    arg1: Type,

2151

    arg2: &ExtendKind,

2152

) -> Gpr {

2153

    let v1 = C::value_type(ctx, arg0);

2154

    if v1 == arg1 {

2155

        let v4 = constructor_put_in_gpr(ctx, arg0);

2156

        // Rule at src/isa/x64/inst.isle line 1738.

2157

        return v4;

2158

2159

    if let &ExtendKind::Zero = arg2 {

2160

        if v1 == I32 {

2161

            if arg1 == I64 {

2162

                let v5 = constructor_value32_zeros_upper32(ctx, arg0);

2163

                if v5 == true {

2164

                    let v4 = constructor_put_in_gpr(ctx, arg0);

2165

                    // Rule at src/isa/x64/inst.isle line 1746.

2166

                    return v4;

2167

2168

2169

2170

        let v6 = C::def_inst(ctx, arg0);

2171

        if let Some(v7) = v6 {

2172

            let v8 = &C::inst_data(ctx, v7);

2173

            if let &InstructionData::BinaryImm8 {

2174

                opcode: ref v9,

2175

                arg: v10,

2176

                imm: v11,

2177

            } = v8

2178

2179

                if let &Opcode::Extractlane = v9 {

2180

                    let v4 = constructor_put_in_gpr(ctx, arg0);

2181

                    // Rule at src/isa/x64/inst.isle line 1762.

2182

                    return v4;

2183

2184

2185

2186

2187

    let v13 = &C::operand_size_of_type_32_64(ctx, arg1);

2188

    let v14 = constructor_operand_size_bits(ctx, v13);

2189

    let v12 = C::ty_bits_u16(ctx, v1);

2190

    let v15 = &C::ext_mode(ctx, v12, v14);

2191

    let v16 = &constructor_put_in_gpr_mem(ctx, arg0);

2192

    let v17 = constructor_extend(ctx, arg2, arg1, v15, v16);

2193

    // Rule at src/isa/x64/inst.isle line 1765.

2194

    return v17;

2195

2196

2197

// Generated as internal constructor for term extend.

2198

pub fn constructor_extend<C: Context>(

2199

    ctx: &mut C,

2200

    arg0: &ExtendKind,

2201

    arg1: Type,

2202

    arg2: &ExtMode,

2203

    arg3: &GprMem,

2204

) -> Gpr {

2205

    match arg0 {

2206

        &ExtendKind::Sign => {

2207

            let v5 = constructor_x64_movsx(ctx, arg2, arg3);

2208

            // Rule at src/isa/x64/inst.isle line 1785.

2209

            return v5;

2210

2211

        &ExtendKind::Zero => {

2212

            let v4 = constructor_x64_movzx(ctx, arg2, arg3);

2213

            // Rule at src/isa/x64/inst.isle line 1781.

2214

            return v4;

2215

2216

        _ => {}

2217

2218

    unreachable!(

2219

        "no rule matched for term {} at {}; should it be partial?",

2220

        "extend", "src/isa/x64/inst.isle line 1778"

2221

2222

2223

2224

// Generated as internal constructor for term value32_zeros_upper32.

2225

pub fn constructor_value32_zeros_upper32<C: Context>(ctx: &mut C, arg0: Value) -> bool {

2226

    let v1 = C::def_inst(ctx, arg0);

2227

    if let Some(v2) = v1 {

2228

        let v3 = &C::inst_data(ctx, v2);

2229

        match v3 {

2230

            &InstructionData::Binary {

2231

                opcode: ref v4,

2232

                args: ref v5,

2233

            } => {

2234

                match v4 {

2235

                    &Opcode::Iadd => {

2236

                        // Rule at src/isa/x64/inst.isle line 1792.

2237

                        return true;

2238

2239

                    &Opcode::Isub => {

2240

                        // Rule at src/isa/x64/inst.isle line 1793.

2241

                        return true;

2242

2243

                    &Opcode::Imul => {

2244

                        // Rule at src/isa/x64/inst.isle line 1794.

2245

                        return true;

2246

2247

                    &Opcode::Band => {

2248

                        // Rule at src/isa/x64/inst.isle line 1795.

2249

                        return true;

2250

2251

                    &Opcode::Bor => {

2252

                        // Rule at src/isa/x64/inst.isle line 1796.

2253

                        return true;

2254

2255

                    &Opcode::Bxor => {

2256

                        // Rule at src/isa/x64/inst.isle line 1797.

2257

                        return true;

2258

2259

                    &Opcode::Ishl => {

2260

                        // Rule at src/isa/x64/inst.isle line 1798.

2261

                        return true;

2262

2263

                    &Opcode::Ushr => {

2264

                        // Rule at src/isa/x64/inst.isle line 1799.

2265

                        return true;

2266

2267

                    _ => {}

2268

2269

2270

            &InstructionData::Load {

2271

                opcode: ref v10,

2272

                arg: v11,

2273

                flags: v12,

2274

                offset: v13,

2275

            } => {

2276

                if let &Opcode::Uload32 = v10 {

2277

                    // Rule at src/isa/x64/inst.isle line 1800.

2278

                    return true;

2279

2280

2281

            _ => {}

2282

2283

2284

    // Rule at src/isa/x64/inst.isle line 1801.

2285

    return false;

2286

2287

2288

// Generated as internal constructor for term vec_int_type.

2289

pub fn constructor_vec_int_type<C: Context>(ctx: &mut C, arg0: Type) -> Type {

2290

    let v1 = C::multi_lane(ctx, arg0);

2291

    if let Some(v2) = v1 {

2292

        match v2.0 {

2293

            0x8 => {

2294

                if v2.1 == 0x10 {

2295

                    // Rule at src/isa/x64/inst.isle line 1807.

2296

                    return I8X16;

2297

2298

2299

            0x10 => {

2300

                if v2.1 == 0x8 {

2301

                    // Rule at src/isa/x64/inst.isle line 1808.

2302

                    return I16X8;

2303

2304

2305

            0x20 => {

2306

                if v2.1 == 0x4 {

2307

                    // Rule at src/isa/x64/inst.isle line 1809.

2308

                    return I32X4;

2309

2310

2311

            0x40 => {

2312

                if v2.1 == 0x2 {

2313

                    // Rule at src/isa/x64/inst.isle line 1810.

2314

                    return I64X2;

2315

2316

2317

            _ => {}

2318

2319

2320

    unreachable!(

2321

        "no rule matched for term {} at {}; should it be partial?",

2322

        "vec_int_type", "src/isa/x64/inst.isle line 1806"

2323

2324

2325

2326

// Generated as internal constructor for term x64_xor_vector.

2327

pub fn constructor_x64_xor_vector<C: Context>(

2328

    ctx: &mut C,

2329

    arg0: Type,

2330

    arg1: Xmm,

2331

    arg2: &XmmMem,

2332

) -> Xmm {

2333

    match arg0 {

2334

        F32 => {

2335

            let v3 = constructor_x64_xorps(ctx, arg1, arg2);

2336

            // Rule at src/isa/x64/inst.isle line 1814.

2337

            return v3;

2338

2339

        F64 => {

2340

            let v4 = constructor_x64_xorpd(ctx, arg1, arg2);

2341

            // Rule at src/isa/x64/inst.isle line 1815.

2342

            return v4;

2343

2344

        F32X4 => {

2345

            let v3 = constructor_x64_xorps(ctx, arg1, arg2);

2346

            // Rule at src/isa/x64/inst.isle line 1816.

2347

            return v3;

2348

2349

        F64X2 => {

2350

            let v4 = constructor_x64_xorpd(ctx, arg1, arg2);

2351

            // Rule at src/isa/x64/inst.isle line 1817.

2352

            return v4;

2353

2354

        _ => {}

2355

2356

    let v5 = C::multi_lane(ctx, arg0);

2357

    if let Some(v6) = v5 {

2358

        let v9 = constructor_x64_pxor(ctx, arg1, arg2);

2359

        // Rule at src/isa/x64/inst.isle line 1818.

2360

        return v9;

2361

2362

    unreachable!(

2363

        "no rule matched for term {} at {}; should it be partial?",

2364

        "x64_xor_vector", "src/isa/x64/inst.isle line 1813"

2365

2366

2367

2368

// Generated as internal constructor for term vector_all_ones.

2369

pub fn constructor_vector_all_ones<C: Context>(ctx: &mut C) -> Xmm {

2370

    let v0 = constructor_xmm_uninit_value(ctx);

2371

    let v1 = &C::xmm_to_xmm_mem(ctx, v0);

2372

    let v2 = constructor_x64_pcmpeqd(ctx, v0, v1);

2373

    // Rule at src/isa/x64/inst.isle line 1830.

2374

    return v2;

2375

2376

2377

// Generated as internal constructor for term xmm_uninit_value.

2378

pub fn constructor_xmm_uninit_value<C: Context>(ctx: &mut C) -> Xmm {

2379

    let v0 = C::temp_writable_xmm(ctx);

2380

    let v1 = MInst::XmmUninitializedValue { dst: v0 };

2381

    let v2 = C::emit(ctx, &v1);

2382

    let v3 = C::writable_xmm_to_xmm(ctx, v0);

2383

    // Rule at src/isa/x64/inst.isle line 1836.

2384

    return v3;

2385

2386

2387

// Generated as internal constructor for term make_i64x2_from_lanes.

2388

pub fn constructor_make_i64x2_from_lanes<C: Context>(

2389

    ctx: &mut C,

2390

    arg0: &GprMem,

2391

    arg1: &GprMem,

2392

) -> Xmm {

2393

    let v2 = constructor_xmm_uninit_value(ctx);

2394

    let v4 = constructor_x64_pinsrq(ctx, v2, arg0, 0x0);

2395

    let v6 = constructor_x64_pinsrq(ctx, v4, arg1, 0x1);

2396

    // Rule at src/isa/x64/inst.isle line 1843.

2397

    return v6;

2398

2399

2400

// Generated as internal constructor for term mov_rmi_to_xmm.

2401

pub fn constructor_mov_rmi_to_xmm<C: Context>(ctx: &mut C, arg0: &RegMemImm) -> XmmMemImm {

2402

    match arg0 {

2403

        &RegMemImm::Reg { reg: v4 } => {

2404

            let v5 = &C::reg_to_gpr_mem(ctx, v4);

2405

            let v6 = constructor_x64_movd_to_xmm(ctx, v5);

2406

            let v7 = &C::xmm_to_xmm_mem_imm(ctx, v6);

2407

            // Rule at src/isa/x64/inst.isle line 1853.

2408

            return v7.clone();

2409

2410

        &RegMemImm::Mem { addr: ref v1 } => {

2411

            let v2 = &C::xmm_mem_imm_new(ctx, arg0);

2412

            // Rule at src/isa/x64/inst.isle line 1851.

2413

            return v2.clone();

2414

2415

        &RegMemImm::Imm { simm32: v3 } => {

2416

            let v2 = &C::xmm_mem_imm_new(ctx, arg0);

2417

            // Rule at src/isa/x64/inst.isle line 1852.

2418

            return v2.clone();

2419

2420

        _ => {}

2421

2422

    unreachable!(

2423

        "no rule matched for term {} at {}; should it be partial?",

2424

        "mov_rmi_to_xmm", "src/isa/x64/inst.isle line 1850"

2425

2426

2427

2428

// Generated as internal constructor for term load_ext_name.

2429

pub fn constructor_load_ext_name<C: Context>(ctx: &mut C, arg0: ExternalName, arg1: i64) -> Reg {

2430

    let v2 = C::temp_writable_gpr(ctx);

2431

    let v3 = C::writable_gpr_to_reg(ctx, v2);

2432

    let v4 = C::box_external_name(ctx, arg0);

2433

    let v5 = MInst::LoadExtName {

2434

        dst: v3,

2435

        name: v4,

2436

        offset: arg1,

2437

};

2438

    let v6 = C::emit(ctx, &v5);

2439

    let v7 = constructor_writable_gpr_to_r_reg(ctx, v2);

2440

    // Rule at src/isa/x64/inst.isle line 1867.

2441

    return v7;

2442

2443

2444

// Generated as internal constructor for term x64_load.

2445

pub fn constructor_x64_load<C: Context>(

2446

    ctx: &mut C,

2447

    arg0: Type,

2448

    arg1: &SyntheticAmode,

2449

    arg2: &ExtKind,

2450

) -> Reg {

2451

    match arg0 {

2452

        I64 => {

2453

            let v11 = C::temp_writable_gpr(ctx);

2454

            let v12 = MInst::Mov64MR {

2455

                src: arg1.clone(),

2456

                dst: v11,

2457

};

2458

            let v13 = C::emit(ctx, &v12);

2459

            let v14 = constructor_writable_gpr_to_r_reg(ctx, v11);

2460

            // Rule at src/isa/x64/inst.isle line 1879.

2461

            return v14;

2462

2463

        F32 => {

2464

            let v15 = constructor_x64_movss_load(ctx, arg1);

2465

            let v16 = C::xmm_to_reg(ctx, v15);

2466

            // Rule at src/isa/x64/inst.isle line 1884.

2467

            return v16;

2468

2469

        F64 => {

2470

            let v17 = constructor_x64_movsd_load(ctx, arg1);

2471

            let v18 = C::xmm_to_reg(ctx, v17);

2472

            // Rule at src/isa/x64/inst.isle line 1887.

2473

            return v18;

2474

2475

        F32X4 => {

2476

            let v19 = constructor_x64_movups_load(ctx, arg1);

2477

            let v20 = C::xmm_to_reg(ctx, v19);

2478

            // Rule at src/isa/x64/inst.isle line 1890.

2479

            return v20;

2480

2481

        F64X2 => {

2482

            let v21 = constructor_x64_movupd_load(ctx, arg1);

2483

            let v22 = C::xmm_to_reg(ctx, v21);

2484

            // Rule at src/isa/x64/inst.isle line 1893.

2485

            return v22;

2486

2487

        _ => {}

2488

2489

    let v1 = C::fits_in_32(ctx, arg0);

2490

    if let Some(v2) = v1 {

2491

        if let &ExtKind::SignExtend = arg2 {

2492

            let v5 = C::ty_bytes(ctx, v2);

2493

            let v7 = &C::ext_mode(ctx, v5, 0x8);

2494

            let v8 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg1);

2495

            let v9 = constructor_x64_movsx(ctx, v7, v8);

2496

            let v10 = C::gpr_to_reg(ctx, v9);

2497

            // Rule at src/isa/x64/inst.isle line 1875.

2498

            return v10;

2499

2500

2501

    let v23 = C::multi_lane(ctx, arg0);

2502

    if let Some(v24) = v23 {

2503

        let v27 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg1);

2504

        let v28 = constructor_x64_movdqu_load(ctx, v27);

2505

        let v29 = C::xmm_to_reg(ctx, v28);

2506

        // Rule at src/isa/x64/inst.isle line 1896.

2507

        return v29;

2508

2509

    unreachable!(

2510

        "no rule matched for term {} at {}; should it be partial?",

2511

        "x64_load", "src/isa/x64/inst.isle line 1873"

2512

2513

2514

2515

// Generated as internal constructor for term x64_mov.

2516

pub fn constructor_x64_mov<C: Context>(ctx: &mut C, arg0: &Amode) -> Reg {

2517

    let v1 = C::temp_writable_gpr(ctx);

2518

    let v2 = &C::amode_to_synthetic_amode(ctx, arg0);

2519

    let v3 = MInst::Mov64MR {

2520

        src: v2.clone(),

2521

        dst: v1,

2522

};

2523

    let v4 = C::emit(ctx, &v3);

2524

    let v5 = constructor_writable_gpr_to_r_reg(ctx, v1);

2525

    // Rule at src/isa/x64/inst.isle line 1900.

2526

    return v5;

2527

2528

2529

// Generated as internal constructor for term x64_movzx.

2530

pub fn constructor_x64_movzx<C: Context>(ctx: &mut C, arg0: &ExtMode, arg1: &GprMem) -> Gpr {

2531

    let v2 = C::temp_writable_gpr(ctx);

2532

    let v3 = MInst::MovzxRmR {

2533

        ext_mode: arg0.clone(),

2534

        src: arg1.clone(),

2535

        dst: v2,

2536

};

2537

    let v4 = C::emit(ctx, &v3);

2538

    let v5 = C::writable_gpr_to_gpr(ctx, v2);

2539

    // Rule at src/isa/x64/inst.isle line 1906.

2540

    return v5;

2541

2542

2543

// Generated as internal constructor for term x64_movsx.

2544

pub fn constructor_x64_movsx<C: Context>(ctx: &mut C, arg0: &ExtMode, arg1: &GprMem) -> Gpr {

2545

    let v2 = C::temp_writable_gpr(ctx);

2546

    let v3 = MInst::MovsxRmR {

2547

        ext_mode: arg0.clone(),

2548

        src: arg1.clone(),

2549

        dst: v2,

2550

};

2551

    let v4 = C::emit(ctx, &v3);

2552

    let v5 = C::writable_gpr_to_gpr(ctx, v2);

2553

    // Rule at src/isa/x64/inst.isle line 1912.

2554

    return v5;

2555

2556

2557

// Generated as internal constructor for term x64_movss_load.

2558

pub fn constructor_x64_movss_load<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Xmm {

2559

    let v4 = C::use_avx_simd(ctx);

2560

    if v4 == true {

2561

        let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

2562

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovss, v2);

2563

        // Rule at src/isa/x64/inst.isle line 1920.

2564

        return v6;

2565

2566

    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

2567

    let v3 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movss, v2);

2568

    // Rule at src/isa/x64/inst.isle line 1918.

2569

    return v3;

2570

2571

2572

// Generated as internal constructor for term x64_movss_store.

2573

pub fn constructor_x64_movss_store<C: Context>(

2574

    ctx: &mut C,

2575

    arg0: &SyntheticAmode,

2576

    arg1: Xmm,

2577

) -> SideEffectNoResult {

2578

    let v4 = C::use_avx_simd(ctx);

2579

    if v4 == true {

2580

        let v6 = &constructor_xmm_movrm_vex(ctx, &AvxOpcode::Vmovss, arg0, arg1);

2581

        // Rule at src/isa/x64/inst.isle line 1927.

2582

        return v6.clone();

2583

2584

    let v3 = &constructor_xmm_movrm(ctx, &SseOpcode::Movss, arg0, arg1);

2585

    // Rule at src/isa/x64/inst.isle line 1925.

2586

    return v3.clone();

2587

2588

2589

// Generated as internal constructor for term x64_movsd_load.

2590

pub fn constructor_x64_movsd_load<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Xmm {

2591

    let v4 = C::use_avx_simd(ctx);

2592

    if v4 == true {

2593

        let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

2594

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovsd, v2);

2595

        // Rule at src/isa/x64/inst.isle line 1934.

2596

        return v6;

2597

2598

    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

2599

    let v3 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movsd, v2);

2600

    // Rule at src/isa/x64/inst.isle line 1932.

2601

    return v3;

2602

2603

2604

// Generated as internal constructor for term x64_movsd_store.

2605

pub fn constructor_x64_movsd_store<C: Context>(

2606

    ctx: &mut C,

2607

    arg0: &SyntheticAmode,

2608

    arg1: Xmm,

2609

) -> SideEffectNoResult {

2610

    let v4 = C::use_avx_simd(ctx);

2611

    if v4 == true {

2612

        let v6 = &constructor_xmm_movrm_vex(ctx, &AvxOpcode::Vmovsd, arg0, arg1);

2613

        // Rule at src/isa/x64/inst.isle line 1941.

2614

        return v6.clone();

2615

2616

    let v3 = &constructor_xmm_movrm(ctx, &SseOpcode::Movsd, arg0, arg1);

2617

    // Rule at src/isa/x64/inst.isle line 1939.

2618

    return v3.clone();

2619

2620

2621

// Generated as internal constructor for term x64_movups_load.

2622

pub fn constructor_x64_movups_load<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Xmm {

2623

    let v4 = C::use_avx_simd(ctx);

2624

    if v4 == true {

2625

        let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

2626

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovups, v2);

2627

        // Rule at src/isa/x64/inst.isle line 1948.

2628

        return v6;

2629

2630

    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

2631

    let v3 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movups, v2);

2632

    // Rule at src/isa/x64/inst.isle line 1946.

2633

    return v3;

2634

2635

2636

// Generated as internal constructor for term x64_movups_store.

2637

pub fn constructor_x64_movups_store<C: Context>(

2638

    ctx: &mut C,

2639

    arg0: &SyntheticAmode,

2640

    arg1: Xmm,

2641

) -> SideEffectNoResult {

2642

    let v4 = C::use_avx_simd(ctx);

2643

    if v4 == true {

2644

        let v6 = &constructor_xmm_movrm_vex(ctx, &AvxOpcode::Vmovups, arg0, arg1);

2645

        // Rule at src/isa/x64/inst.isle line 1955.

2646

        return v6.clone();

2647

2648

    let v3 = &constructor_xmm_movrm(ctx, &SseOpcode::Movups, arg0, arg1);

2649

    // Rule at src/isa/x64/inst.isle line 1953.

2650

    return v3.clone();

2651

2652

2653

// Generated as internal constructor for term x64_movupd_load.

2654

pub fn constructor_x64_movupd_load<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Xmm {

2655

    let v4 = C::use_avx_simd(ctx);

2656

    if v4 == true {

2657

        let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

2658

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovupd, v2);

2659

        // Rule at src/isa/x64/inst.isle line 1962.

2660

        return v6;

2661

2662

    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

2663

    let v3 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movupd, v2);

2664

    // Rule at src/isa/x64/inst.isle line 1960.

2665

    return v3;

2666

2667

2668

// Generated as internal constructor for term x64_movupd_store.

2669

pub fn constructor_x64_movupd_store<C: Context>(

2670

    ctx: &mut C,

2671

    arg0: &SyntheticAmode,

2672

    arg1: Xmm,

2673

) -> SideEffectNoResult {

2674

    let v4 = C::use_avx_simd(ctx);

2675

    if v4 == true {

2676

        let v6 = &constructor_xmm_movrm_vex(ctx, &AvxOpcode::Vmovupd, arg0, arg1);

2677

        // Rule at src/isa/x64/inst.isle line 1969.

2678

        return v6.clone();

2679

2680

    let v3 = &constructor_xmm_movrm(ctx, &SseOpcode::Movupd, arg0, arg1);

2681

    // Rule at src/isa/x64/inst.isle line 1967.

2682

    return v3.clone();

2683

2684

2685

// Generated as internal constructor for term x64_movd_to_gpr.

2686

pub fn constructor_x64_movd_to_gpr<C: Context>(ctx: &mut C, arg0: Xmm) -> Gpr {

2687

    let v4 = C::use_avx_simd(ctx);

2688

    if v4 == true {

2689

        let v6 = constructor_xmm_to_gpr_vex(ctx, &AvxOpcode::Vmovd, arg0, &OperandSize::Size32);

2690

        // Rule at src/isa/x64/inst.isle line 1977.

2691

        return v6;

2692

2693

    let v3 = constructor_xmm_to_gpr(ctx, &SseOpcode::Movd, arg0, &OperandSize::Size32);

2694

    // Rule at src/isa/x64/inst.isle line 1975.

2695

    return v3;

2696

2697

2698

// Generated as internal constructor for term x64_movd_to_xmm.

2699

pub fn constructor_x64_movd_to_xmm<C: Context>(ctx: &mut C, arg0: &GprMem) -> Xmm {

2700

    let v4 = C::use_avx_simd(ctx);

2701

    if v4 == true {

2702

        let v6 = constructor_gpr_to_xmm_vex(ctx, &AvxOpcode::Vmovd, arg0, &OperandSize::Size32);

2703

        // Rule at src/isa/x64/inst.isle line 1985.

2704

        return v6;

2705

2706

    let v3 = constructor_gpr_to_xmm(ctx, &SseOpcode::Movd, arg0, &OperandSize::Size32);

2707

    // Rule at src/isa/x64/inst.isle line 1983.

2708

    return v3;

2709

2710

2711

// Generated as internal constructor for term x64_movq_to_xmm.

2712

pub fn constructor_x64_movq_to_xmm<C: Context>(ctx: &mut C, arg0: &GprMem) -> Xmm {

2713

    let v4 = C::use_avx_simd(ctx);

2714

    if v4 == true {

2715

        let v6 = constructor_gpr_to_xmm_vex(ctx, &AvxOpcode::Vmovq, arg0, &OperandSize::Size64);

2716

        // Rule at src/isa/x64/inst.isle line 1993.

2717

        return v6;

2718

2719

    let v3 = constructor_gpr_to_xmm(ctx, &SseOpcode::Movq, arg0, &OperandSize::Size64);

2720

    // Rule at src/isa/x64/inst.isle line 1991.

2721

    return v3;

2722

2723

2724

// Generated as internal constructor for term x64_movq_to_gpr.

2725

pub fn constructor_x64_movq_to_gpr<C: Context>(ctx: &mut C, arg0: Xmm) -> Gpr {

2726

    let v4 = C::use_avx_simd(ctx);

2727

    if v4 == true {

2728

        let v6 = constructor_xmm_to_gpr_vex(ctx, &AvxOpcode::Vmovq, arg0, &OperandSize::Size64);

2729

        // Rule at src/isa/x64/inst.isle line 2001.

2730

        return v6;

2731

2732

    let v3 = constructor_xmm_to_gpr(ctx, &SseOpcode::Movq, arg0, &OperandSize::Size64);

2733

    // Rule at src/isa/x64/inst.isle line 1999.

2734

    return v3;

2735

2736

2737

// Generated as internal constructor for term x64_movdqu_load.

2738

pub fn constructor_x64_movdqu_load<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

2739

    let v3 = C::use_avx_simd(ctx);

2740

    if v3 == true {

2741

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovdqu, arg0);

2742

        // Rule at src/isa/x64/inst.isle line 2008.

2743

        return v5;

2744

2745

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movdqu, arg0);

2746

    // Rule at src/isa/x64/inst.isle line 2006.

2747

    return v2;

2748

2749

2750

// Generated as internal constructor for term x64_movdqu_store.

2751

pub fn constructor_x64_movdqu_store<C: Context>(

2752

    ctx: &mut C,

2753

    arg0: &SyntheticAmode,

2754

    arg1: Xmm,

2755

) -> SideEffectNoResult {

2756

    let v4 = C::use_avx_simd(ctx);

2757

    if v4 == true {

2758

        let v6 = &constructor_xmm_movrm_vex(ctx, &AvxOpcode::Vmovdqu, arg0, arg1);

2759

        // Rule at src/isa/x64/inst.isle line 2015.

2760

        return v6.clone();

2761

2762

    let v3 = &constructor_xmm_movrm(ctx, &SseOpcode::Movdqu, arg0, arg1);

2763

    // Rule at src/isa/x64/inst.isle line 2013.

2764

    return v3.clone();

2765

2766

2767

// Generated as internal constructor for term x64_pmovsxbw.

2768

pub fn constructor_x64_pmovsxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

2769

    let v3 = C::use_avx_simd(ctx);

2770

    if v3 == true {

2771

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovsxbw, arg0);

2772

        // Rule at src/isa/x64/inst.isle line 2022.

2773

        return v5;

2774

2775

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovsxbw, arg0);

2776

    // Rule at src/isa/x64/inst.isle line 2020.

2777

    return v2;

2778

2779

2780

// Generated as internal constructor for term x64_pmovzxbw.

2781

pub fn constructor_x64_pmovzxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

2782

    let v3 = C::use_avx_simd(ctx);

2783

    if v3 == true {

2784

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovzxbw, arg0);

2785

        // Rule at src/isa/x64/inst.isle line 2029.

2786

        return v5;

2787

2788

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovzxbw, arg0);

2789

    // Rule at src/isa/x64/inst.isle line 2027.

2790

    return v2;

2791

2792

2793

// Generated as internal constructor for term x64_pmovsxwd.

2794

pub fn constructor_x64_pmovsxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

2795

    let v3 = C::use_avx_simd(ctx);

2796

    if v3 == true {

2797

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovsxwd, arg0);

2798

        // Rule at src/isa/x64/inst.isle line 2036.

2799

        return v5;

2800

2801

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovsxwd, arg0);

2802

    // Rule at src/isa/x64/inst.isle line 2034.

2803

    return v2;

2804

2805

2806

// Generated as internal constructor for term x64_pmovzxwd.

2807

pub fn constructor_x64_pmovzxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

2808

    let v3 = C::use_avx_simd(ctx);

2809

    if v3 == true {

2810

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovzxwd, arg0);

2811

        // Rule at src/isa/x64/inst.isle line 2043.

2812

        return v5;

2813

2814

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovzxwd, arg0);

2815

    // Rule at src/isa/x64/inst.isle line 2041.

2816

    return v2;

2817

2818

2819

// Generated as internal constructor for term x64_pmovsxdq.

2820

pub fn constructor_x64_pmovsxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

2821

    let v3 = C::use_avx_simd(ctx);

2822

    if v3 == true {

2823

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovsxdq, arg0);

2824

        // Rule at src/isa/x64/inst.isle line 2050.

2825

        return v5;

2826

2827

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovsxdq, arg0);

2828

    // Rule at src/isa/x64/inst.isle line 2048.

2829

    return v2;

2830

2831

2832

// Generated as internal constructor for term x64_pmovzxdq.

2833

pub fn constructor_x64_pmovzxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

2834

    let v3 = C::use_avx_simd(ctx);

2835

    if v3 == true {

2836

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovzxdq, arg0);

2837

        // Rule at src/isa/x64/inst.isle line 2057.

2838

        return v5;

2839

2840

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovzxdq, arg0);

2841

    // Rule at src/isa/x64/inst.isle line 2055.

2842

    return v2;

2843

2844

2845

// Generated as internal constructor for term x64_movrm.

2846

pub fn constructor_x64_movrm<C: Context>(

2847

    ctx: &mut C,

2848

    arg0: Type,

2849

    arg1: &SyntheticAmode,

2850

    arg2: Gpr,

2851

) -> SideEffectNoResult {

2852

    let v3 = &C::raw_operand_size_of_type(ctx, arg0);

2853

    let v4 = MInst::MovRM {

2854

        size: v3.clone(),

2855

        src: arg2,

2856

        dst: arg1.clone(),

2857

};

2858

    let v5 = SideEffectNoResult::Inst { inst: v4 };

2859

    // Rule at src/isa/x64/inst.isle line 2062.

2860

    return v5;

2861

2862

2863

// Generated as internal constructor for term xmm_movrm.

2864

pub fn constructor_xmm_movrm<C: Context>(

2865

    ctx: &mut C,

2866

    arg0: &SseOpcode,

2867

    arg1: &SyntheticAmode,

2868

    arg2: Xmm,

2869

) -> SideEffectNoResult {

2870

    let v3 = MInst::XmmMovRM {

2871

        op: arg0.clone(),

2872

        src: arg2,

2873

        dst: arg1.clone(),

2874

};

2875

    let v4 = SideEffectNoResult::Inst { inst: v3 };

2876

    // Rule at src/isa/x64/inst.isle line 2067.

2877

    return v4;

2878

2879

2880

// Generated as internal constructor for term xmm_movrm_imm.

2881

pub fn constructor_xmm_movrm_imm<C: Context>(

2882

    ctx: &mut C,

2883

    arg0: &SseOpcode,

2884

    arg1: &SyntheticAmode,

2885

    arg2: Xmm,

2886

    arg3: u8,

2887

) -> SideEffectNoResult {

2888

    let v4 = MInst::XmmMovRMImm {

2889

        op: arg0.clone(),

2890

        src: arg2,

2891

        dst: arg1.clone(),

2892

        imm: arg3,

2893

};

2894

    let v5 = SideEffectNoResult::Inst { inst: v4 };

2895

    // Rule at src/isa/x64/inst.isle line 2071.

2896

    return v5;

2897

2898

2899

// Generated as internal constructor for term xmm_movrm_vex.

2900

pub fn constructor_xmm_movrm_vex<C: Context>(

2901

    ctx: &mut C,

2902

    arg0: &AvxOpcode,

2903

    arg1: &SyntheticAmode,

2904

    arg2: Xmm,

2905

) -> SideEffectNoResult {

2906

    let v3 = MInst::XmmMovRMVex {

2907

        op: arg0.clone(),

2908

        src: arg2,

2909

        dst: arg1.clone(),

2910

};

2911

    let v4 = SideEffectNoResult::Inst { inst: v3 };

2912

    // Rule at src/isa/x64/inst.isle line 2075.

2913

    return v4;

2914

2915

2916

// Generated as internal constructor for term xmm_movrm_imm_vex.

2917

pub fn constructor_xmm_movrm_imm_vex<C: Context>(

2918

    ctx: &mut C,

2919

    arg0: &AvxOpcode,

2920

    arg1: &SyntheticAmode,

2921

    arg2: Xmm,

2922

    arg3: u8,

2923

) -> SideEffectNoResult {

2924

    let v4 = MInst::XmmMovRMImmVex {

2925

        op: arg0.clone(),

2926

        src: arg2,

2927

        dst: arg1.clone(),

2928

        imm: arg3,

2929

};

2930

    let v5 = SideEffectNoResult::Inst { inst: v4 };

2931

    // Rule at src/isa/x64/inst.isle line 2079.

2932

    return v5;

2933

2934

2935

// Generated as internal constructor for term x64_xmm_load_const.

2936

pub fn constructor_x64_xmm_load_const<C: Context>(

2937

    ctx: &mut C,

2938

    arg0: Type,

2939

    arg1: VCodeConstant,

2940

) -> Xmm {

2941

    let v2 = &C::const_to_synthetic_amode(ctx, arg1);

2942

    let v4 = constructor_x64_load(ctx, arg0, v2, &ExtKind::None);

2943

    let v5 = C::xmm_new(ctx, v4);

2944

    // Rule at src/isa/x64/inst.isle line 2084.

2945

    return v5;

2946

2947

2948

// Generated as internal constructor for term alu_rmi_r.

2949

pub fn constructor_alu_rmi_r<C: Context>(

2950

    ctx: &mut C,

2951

    arg0: Type,

2952

    arg1: &AluRmiROpcode,

2953

    arg2: Gpr,

2954

    arg3: &GprMemImm,

2955

) -> Gpr {

2956

    let v4 = C::temp_writable_gpr(ctx);

2957

    let v5 = &C::operand_size_of_type_32_64(ctx, arg0);

2958

    let v6 = MInst::AluRmiR {

2959

        size: v5.clone(),

2960

        op: arg1.clone(),

2961

        src1: arg2,

2962

        src2: arg3.clone(),

2963

        dst: v4,

2964

};

2965

    let v7 = C::emit(ctx, &v6);

2966

    let v8 = C::writable_gpr_to_gpr(ctx, v4);

2967

    // Rule at src/isa/x64/inst.isle line 2095.

2968

    return v8;

2969

2970

2971

// Generated as internal constructor for term x64_add.

2972

pub fn constructor_x64_add<C: Context>(

2973

    ctx: &mut C,

2974

    arg0: Type,

2975

    arg1: Gpr,

2976

    arg2: &GprMemImm,

2977

) -> Gpr {

2978

    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::Add, arg1, arg2);

2979

    // Rule at src/isa/x64/inst.isle line 2103.

2980

    return v4;

2981

2982

2983

// Generated as internal constructor for term x64_add_with_flags_paired.

2984

pub fn constructor_x64_add_with_flags_paired<C: Context>(

2985

    ctx: &mut C,

2986

    arg0: Type,

2987

    arg1: Gpr,

2988

    arg2: &GprMemImm,

2989

) -> ProducesFlags {

2990

    let v3 = C::temp_writable_gpr(ctx);

2991

    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);

2992

    let v7 = constructor_writable_gpr_to_r_reg(ctx, v3);

2993

    let v6 = MInst::AluRmiR {

2994

        size: v4.clone(),

2995

        op: AluRmiROpcode::Add,

2996

        src1: arg1,

2997

        src2: arg2.clone(),

2998

        dst: v3,

2999

};

3000

    let v8 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {

3001

        inst: v6,

3002

        result: v7,

3003

};

3004

    // Rule at src/isa/x64/inst.isle line 2111.

3005

    return v8;

3006

3007

3008

// Generated as internal constructor for term x64_adc_paired.

3009

pub fn constructor_x64_adc_paired<C: Context>(

3010

    ctx: &mut C,

3011

    arg0: Type,

3012

    arg1: Gpr,

3013

    arg2: &GprMemImm,

3014

) -> ConsumesFlags {

3015

    let v3 = C::temp_writable_gpr(ctx);

3016

    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);

3017

    let v7 = constructor_writable_gpr_to_r_reg(ctx, v3);

3018

    let v6 = MInst::AluRmiR {

3019

        size: v4.clone(),

3020

        op: AluRmiROpcode::Adc,

3021

        src1: arg1,

3022

        src2: arg2.clone(),

3023

        dst: v3,

3024

};

3025

    let v8 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {

3026

        inst: v6,

3027

        result: v7,

3028

};

3029

    // Rule at src/isa/x64/inst.isle line 2123.

3030

    return v8;

3031

3032

3033

// Generated as internal constructor for term x64_sub.

3034

pub fn constructor_x64_sub<C: Context>(

3035

    ctx: &mut C,

3036

    arg0: Type,

3037

    arg1: Gpr,

3038

    arg2: &GprMemImm,

3039

) -> Gpr {

3040

    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::Sub, arg1, arg2);

3041

    // Rule at src/isa/x64/inst.isle line 2135.

3042

    return v4;

3043

3044

3045

// Generated as internal constructor for term x64_sub_with_flags_paired.

3046

pub fn constructor_x64_sub_with_flags_paired<C: Context>(

3047

    ctx: &mut C,

3048

    arg0: Type,

3049

    arg1: Gpr,

3050

    arg2: &GprMemImm,

3051

) -> ProducesFlags {

3052

    let v3 = C::temp_writable_gpr(ctx);

3053

    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);

3054

    let v7 = constructor_writable_gpr_to_r_reg(ctx, v3);

3055

    let v6 = MInst::AluRmiR {

3056

        size: v4.clone(),

3057

        op: AluRmiROpcode::Sub,

3058

        src1: arg1,

3059

        src2: arg2.clone(),

3060

        dst: v3,

3061

};

3062

    let v8 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {

3063

        inst: v6,

3064

        result: v7,

3065

};

3066

    // Rule at src/isa/x64/inst.isle line 2143.

3067

    return v8;

3068

3069

3070

// Generated as internal constructor for term x64_sbb_paired.

3071

pub fn constructor_x64_sbb_paired<C: Context>(

3072

    ctx: &mut C,

3073

    arg0: Type,

3074

    arg1: Gpr,

3075

    arg2: &GprMemImm,

3076

) -> ConsumesFlags {

3077

    let v3 = C::temp_writable_gpr(ctx);

3078

    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);

3079

    let v7 = constructor_writable_gpr_to_r_reg(ctx, v3);

3080

    let v6 = MInst::AluRmiR {

3081

        size: v4.clone(),

3082

        op: AluRmiROpcode::Sbb,

3083

        src1: arg1,

3084

        src2: arg2.clone(),

3085

        dst: v3,

3086

};

3087

    let v8 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {

3088

        inst: v6,

3089

        result: v7,

3090

};

3091

    // Rule at src/isa/x64/inst.isle line 2155.

3092

    return v8;

3093

3094

3095

// Generated as internal constructor for term x64_mul.

3096

pub fn constructor_x64_mul<C: Context>(

3097

    ctx: &mut C,

3098

    arg0: Type,

3099

    arg1: Gpr,

3100

    arg2: &GprMemImm,

3101

) -> Gpr {

3102

    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::Mul, arg1, arg2);

3103

    // Rule at src/isa/x64/inst.isle line 2167.

3104

    return v4;

3105

3106

3107

// Generated as internal constructor for term x64_and.

3108

pub fn constructor_x64_and<C: Context>(

3109

    ctx: &mut C,

3110

    arg0: Type,

3111

    arg1: Gpr,

3112

    arg2: &GprMemImm,

3113

) -> Gpr {

3114

    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::And, arg1, arg2);

3115

    // Rule at src/isa/x64/inst.isle line 2175.

3116

    return v4;

3117

3118

3119

// Generated as internal constructor for term x64_and_with_flags_paired.

3120

pub fn constructor_x64_and_with_flags_paired<C: Context>(

3121

    ctx: &mut C,

3122

    arg0: Type,

3123

    arg1: Gpr,

3124

    arg2: &GprMemImm,

3125

) -> ProducesFlags {

3126

    let v3 = C::temp_writable_gpr(ctx);

3127

    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);

3128

    let v6 = MInst::AluRmiR {

3129

        size: v4.clone(),

3130

        op: AluRmiROpcode::And,

3131

        src1: arg1,

3132

        src2: arg2.clone(),

3133

        dst: v3,

3134

};

3135

    let v7 = ProducesFlags::ProducesFlagsSideEffect { inst: v6 };

3136

    // Rule at src/isa/x64/inst.isle line 2182.

3137

    return v7;

3138

3139

3140

// Generated as internal constructor for term x64_or.

3141

pub fn constructor_x64_or<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &GprMemImm) -> Gpr {

3142

    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::Or, arg1, arg2);

3143

    // Rule at src/isa/x64/inst.isle line 2193.

3144

    return v4;

3145

3146

3147

// Generated as internal constructor for term x64_xor.

3148

pub fn constructor_x64_xor<C: Context>(

3149

    ctx: &mut C,

3150

    arg0: Type,

3151

    arg1: Gpr,

3152

    arg2: &GprMemImm,

3153

) -> Gpr {

3154

    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::Xor, arg1, arg2);

3155

    // Rule at src/isa/x64/inst.isle line 2201.

3156

    return v4;

3157

3158

3159

// Generated as internal constructor for term alu_rm_r_vex.

3160

pub fn constructor_alu_rm_r_vex<C: Context>(

3161

    ctx: &mut C,

3162

    arg0: Type,

3163

    arg1: &AluRmROpcode,

3164

    arg2: Gpr,

3165

    arg3: Gpr,

3166

) -> Gpr {

3167

    let v4 = C::temp_writable_gpr(ctx);

3168

    let v5 = &C::operand_size_of_type_32_64(ctx, arg0);

3169

    let v6 = MInst::AluRmRVex {

3170

        size: v5.clone(),

3171

        op: arg1.clone(),

3172

        src1: arg2,

3173

        src2: arg3,

3174

        dst: v4,

3175

};

3176

    let v7 = C::emit(ctx, &v6);

3177

    let v8 = C::writable_gpr_to_gpr(ctx, v4);

3178

    // Rule at src/isa/x64/inst.isle line 2209.

3179

    return v8;

3180

3181

3182

// Generated as internal constructor for term x64_andn.

3183

pub fn constructor_x64_andn<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: Gpr) -> Gpr {

3184

    let v4 = constructor_alu_rm_r_vex(ctx, arg0, &AluRmROpcode::Andn, arg1, arg2);

3185

    // Rule at src/isa/x64/inst.isle line 2216.

3186

    return v4;

3187

3188

3189

// Generated as internal constructor for term imm_i64.

3190

pub fn constructor_imm_i64<C: Context>(ctx: &mut C, arg0: Type, arg1: i64) -> Reg {

3191

    let v2 = C::i64_as_u64(ctx, arg1);

3192

    let v3 = constructor_imm(ctx, arg0, v2);

3193

    // Rule at src/isa/x64/inst.isle line 2223.

3194

    return v3;

3195

3196

3197

// Generated as internal constructor for term imm.

3198

pub fn constructor_imm<C: Context>(ctx: &mut C, arg0: Type, arg1: u64) -> Reg {

3199

    match arg0 {

3200

        I64 => {

3201

            let v20 = C::nonzero_u64_fits_in_u32(ctx, arg1);

3202

            if let Some(v21) = v20 {

3203

                let v5 = C::temp_writable_gpr(ctx);

3204

                let v23 = MInst::Imm {

3205

                    dst_size: OperandSize::Size32,

3206

                    simm64: v21,

3207

                    dst: v5,

3208

};

3209

                let v24 = C::emit(ctx, &v23);

3210

                let v25 = constructor_writable_gpr_to_r_reg(ctx, v5);

3211

                // Rule at src/isa/x64/inst.isle line 2254.

3212

                return v25;

3213

3214

3215

        F32 => {

3216

            let v4 = C::u64_is_zero(ctx, arg1);

3217

            match v4 {

3218

                true => {

3219

                    let v35 = constructor_xmm_zero(ctx, arg0);

3220

                    let v36 = C::xmm_to_reg(ctx, v35);

3221

                    // Rule at src/isa/x64/inst.isle line 2272.

3222

                    return v36;

3223

3224

                false => {

3225

                    let v11 = constructor_imm(ctx, I32, arg1);

3226

                    let v12 = &C::reg_to_gpr_mem(ctx, v11);

3227

                    let v13 = constructor_x64_movd_to_xmm(ctx, v12);

3228

                    let v14 = C::xmm_to_reg(ctx, v13);

3229

                    // Rule at src/isa/x64/inst.isle line 2245.

3230

                    return v14;

3231

3232

                _ => {}

3233

3234

3235

        F64 => {

3236

            let v4 = C::u64_is_zero(ctx, arg1);

3237

            match v4 {

3238

                true => {

3239

                    let v35 = constructor_xmm_zero(ctx, arg0);

3240

                    let v36 = C::xmm_to_reg(ctx, v35);

3241

                    // Rule at src/isa/x64/inst.isle line 2277.

3242

                    return v36;

3243

3244

                false => {

3245

                    let v16 = constructor_imm(ctx, I64, arg1);

3246

                    let v17 = &C::reg_to_gpr_mem(ctx, v16);

3247

                    let v18 = constructor_x64_movq_to_xmm(ctx, v17);

3248

                    let v19 = C::xmm_to_reg(ctx, v18);

3249

                    // Rule at src/isa/x64/inst.isle line 2249.

3250

                    return v19;

3251

3252

                _ => {}

3253

3254

3255

        _ => {}

3256

3257

    let v1 = C::fits_in_64(ctx, arg0);

3258

    if let Some(v2) = v1 {

3259

        let v4 = C::u64_is_zero(ctx, arg1);

3260

        match v4 {

3261

            true => {

3262

                let v5 = C::temp_writable_gpr(ctx);

3263

                let v6 = &C::operand_size_of_type_32_64(ctx, v2);

3264

                let v27 = MInst::AluConstOp {

3265

                    op: AluRmiROpcode::Xor,

3266

                    size: v6.clone(),

3267

                    dst: v5,

3268

};

3269

                let v28 = C::emit(ctx, &v27);

3270

                let v29 = C::writable_gpr_to_gpr(ctx, v5);

3271

                let v30 = C::gpr_to_reg(ctx, v29);

3272

                // Rule at src/isa/x64/inst.isle line 2260.

3273

                return v30;

3274

3275

            false => {

3276

                let v5 = C::temp_writable_gpr(ctx);

3277

                let v6 = &C::operand_size_of_type_32_64(ctx, v2);

3278

                let v7 = MInst::Imm {

3279

                    dst_size: v6.clone(),

3280

                    simm64: arg1,

3281

                    dst: v5,

3282

};

3283

                let v8 = C::emit(ctx, &v7);

3284

                let v9 = constructor_writable_gpr_to_r_reg(ctx, v5);

3285

                // Rule at src/isa/x64/inst.isle line 2238.

3286

                return v9;

3287

3288

            _ => {}

3289

3290

3291

    if arg1 == 0x0 {

3292

        let v31 = C::multi_lane(ctx, arg0);

3293

        if let Some(v32) = v31 {

3294

            let v35 = constructor_xmm_zero(ctx, arg0);

3295

            let v36 = C::xmm_to_reg(ctx, v35);

3296

            // Rule at src/isa/x64/inst.isle line 2268.

3297

            return v36;

3298

3299

3300

    unreachable!(

3301

        "no rule matched for term {} at {}; should it be partial?",

3302

        "imm", "src/isa/x64/inst.isle line 2235"

3303

3304

3305

3306

// Generated as internal constructor for term xmm_zero.

3307

pub fn constructor_xmm_zero<C: Context>(ctx: &mut C, arg0: Type) -> Xmm {

3308

    let v1 = constructor_xmm_uninit_value(ctx);

3309

    let v2 = &C::xmm_to_xmm_mem(ctx, v1);

3310

    let v3 = constructor_x64_xor_vector(ctx, arg0, v1, v2);

3311

    // Rule at src/isa/x64/inst.isle line 2282.

3312

    return v3;

3313

3314

3315

// Generated as internal constructor for term shift_r.

3316

pub fn constructor_shift_r<C: Context>(

3317

    ctx: &mut C,

3318

    arg0: Type,

3319

    arg1: &ShiftKind,

3320

    arg2: Gpr,

3321

    arg3: &Imm8Gpr,

3322

) -> Gpr {

3323

    let v4 = C::temp_writable_gpr(ctx);

3324

    let v5 = &C::raw_operand_size_of_type(ctx, arg0);

3325

    let v6 = MInst::ShiftR {

3326

        size: v5.clone(),

3327

        kind: arg1.clone(),

3328

        src: arg2,

3329

        num_bits: arg3.clone(),

3330

        dst: v4,

3331

};

3332

    let v7 = C::emit(ctx, &v6);

3333

    let v8 = C::writable_gpr_to_gpr(ctx, v4);

3334

    // Rule at src/isa/x64/inst.isle line 2288.

3335

    return v8;

3336

3337

3338

// Generated as internal constructor for term x64_rotl.

3339

pub fn constructor_x64_rotl<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &Imm8Gpr) -> Gpr {

3340

    let v4 = constructor_shift_r(ctx, arg0, &ShiftKind::RotateLeft, arg1, arg2);

3341

    // Rule at src/isa/x64/inst.isle line 2298.

3342

    return v4;

3343

3344

3345

// Generated as internal constructor for term x64_rotr.

3346

pub fn constructor_x64_rotr<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &Imm8Gpr) -> Gpr {

3347

    let v4 = constructor_shift_r(ctx, arg0, &ShiftKind::RotateRight, arg1, arg2);

3348

    // Rule at src/isa/x64/inst.isle line 2303.

3349

    return v4;

3350

3351

3352

// Generated as internal constructor for term x64_shl.

3353

pub fn constructor_x64_shl<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &Imm8Gpr) -> Gpr {

3354

    let v4 = constructor_shift_r(ctx, arg0, &ShiftKind::ShiftLeft, arg1, arg2);

3355

    // Rule at src/isa/x64/inst.isle line 2308.

3356

    return v4;

3357

3358

3359

// Generated as internal constructor for term x64_shr.

3360

pub fn constructor_x64_shr<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &Imm8Gpr) -> Gpr {

3361

    let v4 = constructor_shift_r(ctx, arg0, &ShiftKind::ShiftRightLogical, arg1, arg2);

3362

    // Rule at src/isa/x64/inst.isle line 2313.

3363

    return v4;

3364

3365

3366

// Generated as internal constructor for term x64_sar.

3367

pub fn constructor_x64_sar<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &Imm8Gpr) -> Gpr {

3368

    let v4 = constructor_shift_r(ctx, arg0, &ShiftKind::ShiftRightArithmetic, arg1, arg2);

3369

    // Rule at src/isa/x64/inst.isle line 2318.

3370

    return v4;

3371

3372

3373

// Generated as internal constructor for term x64_bswap.

3374

pub fn constructor_x64_bswap<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

3375

    let v2 = C::temp_writable_gpr(ctx);

3376

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

3377

    let v4 = MInst::Bswap {

3378

        size: v3.clone(),

3379

        src: arg1,

3380

        dst: v2,

3381

};

3382

    let v5 = C::emit(ctx, &v4);

3383

    let v6 = C::writable_gpr_to_gpr(ctx, v2);

3384

    // Rule at src/isa/x64/inst.isle line 2325.

3385

    return v6;

3386

3387

3388

// Generated as internal constructor for term cmp_rmi_r.

3389

pub fn constructor_cmp_rmi_r<C: Context>(

3390

    ctx: &mut C,

3391

    arg0: &OperandSize,

3392

    arg1: &CmpOpcode,

3393

    arg2: &GprMemImm,

3394

    arg3: Gpr,

3395

) -> ProducesFlags {

3396

    let v4 = MInst::CmpRmiR {

3397

        size: arg0.clone(),

3398

        opcode: arg1.clone(),

3399

        src: arg2.clone(),

3400

        dst: arg3,

3401

};

3402

    let v5 = ProducesFlags::ProducesFlagsSideEffect { inst: v4 };

3403

    // Rule at src/isa/x64/inst.isle line 2333.

3404

    return v5;

3405

3406

3407

// Generated as internal constructor for term x64_cmp.

3408

pub fn constructor_x64_cmp<C: Context>(

3409

    ctx: &mut C,

3410

    arg0: &OperandSize,

3411

    arg1: &GprMemImm,

3412

    arg2: Gpr,

3413

) -> ProducesFlags {

3414

    let v4 = &constructor_cmp_rmi_r(ctx, arg0, &CmpOpcode::Cmp, arg1, arg2);

3415

    // Rule at src/isa/x64/inst.isle line 2342.

3416

    return v4.clone();

3417

3418

3419

// Generated as internal constructor for term x64_cmp_imm.

3420

pub fn constructor_x64_cmp_imm<C: Context>(

3421

    ctx: &mut C,

3422

    arg0: &OperandSize,

3423

    arg1: u32,

3424

    arg2: Gpr,

3425

) -> ProducesFlags {

3426

    let v4 = RegMemImm::Imm { simm32: arg1 };

3427

    let v5 = &C::gpr_mem_imm_new(ctx, &v4);

3428

    let v6 = &constructor_cmp_rmi_r(ctx, arg0, &CmpOpcode::Cmp, v5, arg2);

3429

    // Rule at src/isa/x64/inst.isle line 2347.

3430

    return v6.clone();

3431

3432

3433

// Generated as internal constructor for term xmm_cmp_rm_r.

3434

pub fn constructor_xmm_cmp_rm_r<C: Context>(

3435

    ctx: &mut C,

3436

    arg0: &SseOpcode,

3437

    arg1: &XmmMemAligned,

3438

    arg2: Xmm,

3439

) -> ProducesFlags {

3440

    let v3 = MInst::XmmCmpRmR {

3441

        op: arg0.clone(),

3442

        src: arg1.clone(),

3443

        dst: arg2,

3444

};

3445

    let v4 = ProducesFlags::ProducesFlagsSideEffect { inst: v3 };

3446

    // Rule at src/isa/x64/inst.isle line 2352.

3447

    return v4;

3448

3449

3450

// Generated as internal constructor for term x64_ucomis.

3451

pub fn constructor_x64_ucomis<C: Context>(ctx: &mut C, arg0: Value, arg1: Value) -> ProducesFlags {

3452

    let v1 = C::value_type(ctx, arg0);

3453

    match v1 {

3454

        F32 => {

3455

            let v4 = constructor_put_in_xmm(ctx, arg0);

3456

            let v5 = &constructor_xmm_to_xmm_mem_aligned(ctx, v4);

3457

            let v6 = constructor_put_in_xmm(ctx, arg1);

3458

            let v7 = &constructor_xmm_cmp_rm_r(ctx, &SseOpcode::Ucomiss, v5, v6);

3459

            // Rule at src/isa/x64/inst.isle line 2358.

3460

            return v7.clone();

3461

3462

        F64 => {

3463

            let v4 = constructor_put_in_xmm(ctx, arg0);

3464

            let v5 = &constructor_xmm_to_xmm_mem_aligned(ctx, v4);

3465

            let v6 = constructor_put_in_xmm(ctx, arg1);

3466

            let v9 = &constructor_xmm_cmp_rm_r(ctx, &SseOpcode::Ucomisd, v5, v6);

3467

            // Rule at src/isa/x64/inst.isle line 2362.

3468

            return v9.clone();

3469

3470

        _ => {}

3471

3472

    unreachable!(

3473

        "no rule matched for term {} at {}; should it be partial?",

3474

        "x64_ucomis", "src/isa/x64/inst.isle line 2357"

3475

3476

3477

3478

// Generated as internal constructor for term x64_test.

3479

pub fn constructor_x64_test<C: Context>(

3480

    ctx: &mut C,

3481

    arg0: &OperandSize,

3482

    arg1: &GprMemImm,

3483

    arg2: Gpr,

3484

) -> ProducesFlags {

3485

    let v4 = &constructor_cmp_rmi_r(ctx, arg0, &CmpOpcode::Test, arg1, arg2);

3486

    // Rule at src/isa/x64/inst.isle line 2367.

3487

    return v4.clone();

3488

3489

3490

// Generated as internal constructor for term x64_ptest.

3491

pub fn constructor_x64_ptest<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: Xmm) -> ProducesFlags {

3492

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

3493

    let v4 = &constructor_xmm_cmp_rm_r(ctx, &SseOpcode::Ptest, v3, arg1);

3494

    // Rule at src/isa/x64/inst.isle line 2372.

3495

    return v4.clone();

3496

3497

3498

// Generated as internal constructor for term cmove.

3499

pub fn constructor_cmove<C: Context>(

3500

    ctx: &mut C,

3501

    arg0: Type,

3502

    arg1: &CC,

3503

    arg2: &GprMem,

3504

    arg3: Gpr,

3505

) -> ConsumesFlags {

3506

    let v4 = C::temp_writable_gpr(ctx);

3507

    let v5 = &C::operand_size_of_type_32_64(ctx, arg0);

3508

    let v7 = constructor_writable_gpr_to_r_reg(ctx, v4);

3509

    let v6 = MInst::Cmove {

3510

        size: v5.clone(),

3511

        cc: arg1.clone(),

3512

        consequent: arg2.clone(),

3513

        alternative: arg3,

3514

        dst: v4,

3515

};

3516

    let v8 = ConsumesFlags::ConsumesFlagsReturnsReg {

3517

        inst: v6,

3518

        result: v7,

3519

};

3520

    // Rule at src/isa/x64/inst.isle line 2379.

3521

    return v8;

3522

3523

3524

// Generated as internal constructor for term cmove_xmm.

3525

pub fn constructor_cmove_xmm<C: Context>(

3526

    ctx: &mut C,

3527

    arg0: Type,

3528

    arg1: &CC,

3529

    arg2: &XmmMemAligned,

3530

    arg3: Xmm,

3531

) -> ConsumesFlags {

3532

    let v4 = C::temp_writable_xmm(ctx);

3533

    let v6 = constructor_writable_xmm_to_r_reg(ctx, v4);

3534

    let v5 = MInst::XmmCmove {

3535

        ty: arg0,

3536

        cc: arg1.clone(),

3537

        consequent: arg2.clone(),

3538

        alternative: arg3,

3539

        dst: v4,

3540

};

3541

    let v7 = ConsumesFlags::ConsumesFlagsReturnsReg {

3542

        inst: v5,

3543

        result: v6,

3544

};

3545

    // Rule at src/isa/x64/inst.isle line 2387.

3546

    return v7;

3547

3548

3549

// Generated as internal constructor for term cmove_from_values.

3550

pub fn constructor_cmove_from_values<C: Context>(

3551

    ctx: &mut C,

3552

    arg0: Type,

3553

    arg1: &CC,

3554

    arg2: Value,

3555

    arg3: Value,

3556

) -> ConsumesFlags {

3557

    let v1 = &C::type_register_class(ctx, arg0);

3558

    if let Some(v2) = v1 {

3559

        match v2 {

3560

            &RegisterClass::Gpr {

3561

                single_register: v3,

3562

            } => {

3563

                match v3 {

3564

                    true => {

3565

                        let v26 = &constructor_put_in_gpr_mem(ctx, arg2);

3566

                        let v27 = constructor_put_in_gpr(ctx, arg3);

3567

                        let v28 = &constructor_cmove(ctx, arg0, arg1, v26, v27);

3568

                        // Rule at src/isa/x64/inst.isle line 2418.

3569

                        return v28.clone();

3570

3571

                    false => {

3572

                        if arg0 == I128 {

3573

                            let v7 = C::put_in_regs(ctx, arg2);

3574

                            let v8 = C::put_in_regs(ctx, arg3);

3575

                            let v9 = C::temp_writable_gpr(ctx);

3576

                            let v10 = C::temp_writable_gpr(ctx);

3577

                            let v13 = constructor_value_regs_get_gpr(ctx, v7, 0x0);

3578

                            let v14 = &C::gpr_to_gpr_mem(ctx, v13);

3579

                            let v15 = constructor_value_regs_get_gpr(ctx, v8, 0x0);

3580

                            let v18 = constructor_value_regs_get_gpr(ctx, v7, 0x1);

3581

                            let v19 = &C::gpr_to_gpr_mem(ctx, v18);

3582

                            let v20 = constructor_value_regs_get_gpr(ctx, v8, 0x1);

3583

                            let v22 = constructor_writable_gpr_to_r_reg(ctx, v9);

3584

                            let v23 = constructor_writable_gpr_to_r_reg(ctx, v10);

3585

                            let v24 = C::value_regs(ctx, v22, v23);

3586

                            let v16 = MInst::Cmove {

3587

                                size: OperandSize::Size64,

3588

                                cc: arg1.clone(),

3589

                                consequent: v14.clone(),

3590

                                alternative: v15,

3591

                                dst: v9,

3592

};

3593

                            let v21 = MInst::Cmove {

3594

                                size: OperandSize::Size64,

3595

                                cc: arg1.clone(),

3596

                                consequent: v19.clone(),

3597

                                alternative: v20,

3598

                                dst: v10,

3599

};

3600

                            let v25 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

3601

                                inst1: v16,

3602

                                inst2: v21,

3603

                                result: v24,

3604

};

3605

                            // Rule at src/isa/x64/inst.isle line 2397.

3606

                            return v25;

3607

3608

3609

                    _ => {}

3610

3611

3612

            &RegisterClass::Xmm => {

3613

                let v29 = &constructor_put_in_xmm_mem_aligned(ctx, arg2);

3614

                let v30 = constructor_put_in_xmm(ctx, arg3);

3615

                let v31 = &constructor_cmove_xmm(ctx, arg0, arg1, v29, v30);

3616

                // Rule at src/isa/x64/inst.isle line 2421.

3617

                return v31.clone();

3618

3619

            _ => {}

3620

3621

3622

    unreachable!(

3623

        "no rule matched for term {} at {}; should it be partial?",

3624

        "cmove_from_values", "src/isa/x64/inst.isle line 2396"

3625

3626

3627

3628

// Generated as internal constructor for term cmove_or.

3629

pub fn constructor_cmove_or<C: Context>(

3630

    ctx: &mut C,

3631

    arg0: Type,

3632

    arg1: &CC,

3633

    arg2: &CC,

3634

    arg3: &GprMem,

3635

    arg4: Gpr,

3636

) -> ConsumesFlags {

3637

    let v5 = C::temp_writable_gpr(ctx);

3638

    let v6 = C::temp_writable_gpr(ctx);

3639

    let v7 = &C::operand_size_of_type_32_64(ctx, arg0);

3640

    let v9 = C::writable_gpr_to_gpr(ctx, v6);

3641

    let v11 = constructor_writable_gpr_to_value_regs(ctx, v5);

3642

    let v8 = MInst::Cmove {

3643

        size: v7.clone(),

3644

        cc: arg1.clone(),

3645

        consequent: arg3.clone(),

3646

        alternative: arg4,

3647

        dst: v6,

3648

};

3649

    let v10 = MInst::Cmove {

3650

        size: v7.clone(),

3651

        cc: arg2.clone(),

3652

        consequent: arg3.clone(),

3653

        alternative: v9,

3654

        dst: v5,

3655

};

3656

    let v12 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

3657

        inst1: v8,

3658

        inst2: v10,

3659

        result: v11,

3660

};

3661

    // Rule at src/isa/x64/inst.isle line 2428.

3662

    return v12;

3663

3664

3665

// Generated as internal constructor for term cmove_or_xmm.

3666

pub fn constructor_cmove_or_xmm<C: Context>(

3667

    ctx: &mut C,

3668

    arg0: Type,

3669

    arg1: &CC,

3670

    arg2: &CC,

3671

    arg3: &XmmMemAligned,

3672

    arg4: Xmm,

3673

) -> ConsumesFlags {

3674

    let v5 = C::temp_writable_xmm(ctx);

3675

    let v6 = C::temp_writable_xmm(ctx);

3676

    let v8 = C::writable_xmm_to_xmm(ctx, v6);

3677

    let v10 = constructor_writable_xmm_to_value_regs(ctx, v5);

3678

    let v7 = MInst::XmmCmove {

3679

        ty: arg0,

3680

        cc: arg1.clone(),

3681

        consequent: arg3.clone(),

3682

        alternative: arg4,

3683

        dst: v6,

3684

};

3685

    let v9 = MInst::XmmCmove {

3686

        ty: arg0,

3687

        cc: arg2.clone(),

3688

        consequent: arg3.clone(),

3689

        alternative: v8,

3690

        dst: v5,

3691

};

3692

    let v11 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

3693

        inst1: v7,

3694

        inst2: v9,

3695

        result: v10,

3696

};

3697

    // Rule at src/isa/x64/inst.isle line 2440.

3698

    return v11;

3699

3700

3701

// Generated as internal constructor for term cmove_or_from_values.

3702

pub fn constructor_cmove_or_from_values<C: Context>(

3703

    ctx: &mut C,

3704

    arg0: Type,

3705

    arg1: &CC,

3706

    arg2: &CC,

3707

    arg3: Value,

3708

    arg4: Value,

3709

) -> ConsumesFlags {

3710

    let v1 = &C::type_register_class(ctx, arg0);

3711

    if let Some(v2) = v1 {

3712

        match v2 {

3713

            &RegisterClass::Gpr {

3714

                single_register: v3,

3715

            } => {

3716

                match v3 {

3717

                    true => {

3718

                        let v37 = &constructor_put_in_gpr_mem(ctx, arg3);

3719

                        let v38 = constructor_put_in_gpr(ctx, arg4);

3720

                        let v39 = &constructor_cmove_or(ctx, arg0, arg1, arg2, v37, v38);

3721

                        // Rule at src/isa/x64/inst.isle line 2473.

3722

                        return v39.clone();

3723

3724

                    false => {

3725

                        if arg0 == I128 {

3726

                            let v8 = C::put_in_regs(ctx, arg3);

3727

                            let v9 = C::put_in_regs(ctx, arg4);

3728

                            let v10 = C::temp_writable_gpr(ctx);

3729

                            let v11 = C::temp_writable_gpr(ctx);

3730

                            let v12 = C::temp_writable_gpr(ctx);

3731

                            let v13 = C::temp_writable_gpr(ctx);

3732

                            let v16 = constructor_value_regs_get_gpr(ctx, v8, 0x0);

3733

                            let v17 = &C::gpr_to_gpr_mem(ctx, v16);

3734

                            let v18 = constructor_value_regs_get_gpr(ctx, v9, 0x0);

3735

                            let v20 = constructor_value_regs_get_gpr(ctx, v8, 0x0);

3736

                            let v21 = &C::gpr_to_gpr_mem(ctx, v20);

3737

                            let v22 = C::writable_gpr_to_gpr(ctx, v12);

3738

                            let v25 = constructor_value_regs_get_gpr(ctx, v8, 0x1);

3739

                            let v26 = &C::gpr_to_gpr_mem(ctx, v25);

3740

                            let v27 = constructor_value_regs_get_gpr(ctx, v9, 0x1);

3741

                            let v29 = constructor_value_regs_get_gpr(ctx, v8, 0x1);

3742

                            let v30 = &C::gpr_to_gpr_mem(ctx, v29);

3743

                            let v31 = C::writable_gpr_to_gpr(ctx, v13);

3744

                            let v33 = constructor_writable_gpr_to_r_reg(ctx, v10);

3745

                            let v34 = constructor_writable_gpr_to_r_reg(ctx, v11);

3746

                            let v35 = C::value_regs(ctx, v33, v34);

3747

                            let v19 = MInst::Cmove {

3748

                                size: OperandSize::Size64,

3749

                                cc: arg1.clone(),

3750

                                consequent: v17.clone(),

3751

                                alternative: v18,

3752

                                dst: v12,

3753

};

3754

                            let v23 = MInst::Cmove {

3755

                                size: OperandSize::Size64,

3756

                                cc: arg2.clone(),

3757

                                consequent: v21.clone(),

3758

                                alternative: v22,

3759

                                dst: v10,

3760

};

3761

                            let v28 = MInst::Cmove {

3762

                                size: OperandSize::Size64,

3763

                                cc: arg1.clone(),

3764

                                consequent: v26.clone(),

3765

                                alternative: v27,

3766

                                dst: v13,

3767

};

3768

                            let v32 = MInst::Cmove {

3769

                                size: OperandSize::Size64,

3770

                                cc: arg2.clone(),

3771

                                consequent: v30.clone(),

3772

                                alternative: v31,

3773

                                dst: v11,

3774

};

3775

                            let v36 = ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {

3776

                                inst1: v19,

3777

                                inst2: v23,

3778

                                inst3: v28,

3779

                                inst4: v32,

3780

                                result: v35,

3781

};

3782

                            // Rule at src/isa/x64/inst.isle line 2454.

3783

                            return v36;

3784

3785

3786

                    _ => {}

3787

3788

3789

            &RegisterClass::Xmm => {

3790

                let v40 = &constructor_put_in_xmm_mem_aligned(ctx, arg3);

3791

                let v41 = constructor_put_in_xmm(ctx, arg4);

3792

                let v42 = &constructor_cmove_or_xmm(ctx, arg0, arg1, arg2, v40, v41);

3793

                // Rule at src/isa/x64/inst.isle line 2476.

3794

                return v42.clone();

3795

3796

            _ => {}

3797

3798

3799

    unreachable!(

3800

        "no rule matched for term {} at {}; should it be partial?",

3801

        "cmove_or_from_values", "src/isa/x64/inst.isle line 2453"

3802

3803

3804

3805

// Generated as internal constructor for term x64_setcc.

3806

pub fn constructor_x64_setcc<C: Context>(ctx: &mut C, arg0: &CC) -> ConsumesFlags {

3807

    let v1 = C::temp_writable_gpr(ctx);

3808

    let v3 = constructor_writable_gpr_to_r_reg(ctx, v1);

3809

    let v2 = MInst::Setcc {

3810

        cc: arg0.clone(),

3811

        dst: v1,

3812

};

3813

    let v4 = ConsumesFlags::ConsumesFlagsReturnsReg {

3814

        inst: v2,

3815

        result: v3,

3816

};

3817

    // Rule at src/isa/x64/inst.isle line 2481.

3818

    return v4;

3819

3820

3821

// Generated as internal constructor for term x64_setcc_paired.

3822

pub fn constructor_x64_setcc_paired<C: Context>(ctx: &mut C, arg0: &CC) -> ConsumesFlags {

3823

    let v1 = C::temp_writable_gpr(ctx);

3824

    let v3 = constructor_writable_gpr_to_r_reg(ctx, v1);

3825

    let v2 = MInst::Setcc {

3826

        cc: arg0.clone(),

3827

        dst: v1,

3828

};

3829

    let v4 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {

3830

        inst: v2,

3831

        result: v3,

3832

};

3833

    // Rule at src/isa/x64/inst.isle line 2490.

3834

    return v4;

3835

3836

3837

// Generated as internal constructor for term xmm_rm_r.

3838

pub fn constructor_xmm_rm_r<C: Context>(

3839

    ctx: &mut C,

3840

    arg0: &SseOpcode,

3841

    arg1: Xmm,

3842

    arg2: &XmmMemAligned,

3843

) -> Xmm {

3844

    let v3 = C::temp_writable_xmm(ctx);

3845

    let v4 = MInst::XmmRmR {

3846

        op: arg0.clone(),

3847

        src1: arg1,

3848

        src2: arg2.clone(),

3849

        dst: v3,

3850

};

3851

    let v5 = C::emit(ctx, &v4);

3852

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

3853

    // Rule at src/isa/x64/inst.isle line 2498.

3854

    return v6;

3855

3856

3857

// Generated as internal constructor for term xmm_rm_r_unaligned.

3858

pub fn constructor_xmm_rm_r_unaligned<C: Context>(

3859

    ctx: &mut C,

3860

    arg0: &SseOpcode,

3861

    arg1: Xmm,

3862

    arg2: &XmmMem,

3863

) -> Xmm {

3864

    let v3 = C::temp_writable_xmm(ctx);

3865

    let v4 = MInst::XmmRmRUnaligned {

3866

        op: arg0.clone(),

3867

        src1: arg1,

3868

        src2: arg2.clone(),

3869

        dst: v3,

3870

};

3871

    let v5 = C::emit(ctx, &v4);

3872

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

3873

    // Rule at src/isa/x64/inst.isle line 2505.

3874

    return v6;

3875

3876

3877

// Generated as internal constructor for term x64_paddb.

3878

pub fn constructor_x64_paddb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

3879

    let v5 = C::use_avx_simd(ctx);

3880

    if v5 == true {

3881

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

3882

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddb, arg0, v7);

3883

        // Rule at src/isa/x64/inst.isle line 2514.

3884

        return v8;

3885

3886

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

3887

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddb, arg0, v3);

3888

    // Rule at src/isa/x64/inst.isle line 2512.

3889

    return v4;

3890

3891

3892

// Generated as internal constructor for term x64_paddw.

3893

pub fn constructor_x64_paddw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

3894

    let v5 = C::use_avx_simd(ctx);

3895

    if v5 == true {

3896

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

3897

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddw, arg0, v7);

3898

        // Rule at src/isa/x64/inst.isle line 2522.

3899

        return v8;

3900

3901

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

3902

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddw, arg0, v3);

3903

    // Rule at src/isa/x64/inst.isle line 2520.

3904

    return v4;

3905

3906

3907

// Generated as internal constructor for term x64_paddd.

3908

pub fn constructor_x64_paddd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

3909

    let v5 = C::use_avx_simd(ctx);

3910

    if v5 == true {

3911

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

3912

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddd, arg0, v7);

3913

        // Rule at src/isa/x64/inst.isle line 2530.

3914

        return v8;

3915

3916

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

3917

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddd, arg0, v3);

3918

    // Rule at src/isa/x64/inst.isle line 2528.

3919

    return v4;

3920

3921

3922

// Generated as internal constructor for term x64_paddq.

3923

pub fn constructor_x64_paddq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

3924

    let v5 = C::use_avx_simd(ctx);

3925

    if v5 == true {

3926

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

3927

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddq, arg0, v7);

3928

        // Rule at src/isa/x64/inst.isle line 2538.

3929

        return v8;

3930

3931

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

3932

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddq, arg0, v3);

3933

    // Rule at src/isa/x64/inst.isle line 2536.

3934

    return v4;

3935

3936

3937

// Generated as internal constructor for term x64_paddsb.

3938

pub fn constructor_x64_paddsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

3939

    let v5 = C::use_avx_simd(ctx);

3940

    if v5 == true {

3941

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

3942

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddsb, arg0, v7);

3943

        // Rule at src/isa/x64/inst.isle line 2546.

3944

        return v8;

3945

3946

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

3947

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddsb, arg0, v3);

3948

    // Rule at src/isa/x64/inst.isle line 2544.

3949

    return v4;

3950

3951

3952

// Generated as internal constructor for term x64_paddsw.

3953

pub fn constructor_x64_paddsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

3954

    let v5 = C::use_avx_simd(ctx);

3955

    if v5 == true {

3956

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

3957

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddsw, arg0, v7);

3958

        // Rule at src/isa/x64/inst.isle line 2554.

3959

        return v8;

3960

3961

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

3962

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddsw, arg0, v3);

3963

    // Rule at src/isa/x64/inst.isle line 2552.

3964

    return v4;

3965

3966

3967

// Generated as internal constructor for term x64_phaddw.

3968

pub fn constructor_x64_phaddw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

3969

    let v5 = C::use_avx_simd(ctx);

3970

    if v5 == true {

3971

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

3972

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vphaddw, arg0, v7);

3973

        // Rule at src/isa/x64/inst.isle line 2562.

3974

        return v8;

3975

3976

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

3977

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Phaddw, arg0, v3);

3978

    // Rule at src/isa/x64/inst.isle line 2560.

3979

    return v4;

3980

3981

3982

// Generated as internal constructor for term x64_phaddd.

3983

pub fn constructor_x64_phaddd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

3984

    let v5 = C::use_avx_simd(ctx);

3985

    if v5 == true {

3986

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

3987

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vphaddd, arg0, v7);

3988

        // Rule at src/isa/x64/inst.isle line 2570.

3989

        return v8;

3990

3991

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

3992

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Phaddd, arg0, v3);

3993

    // Rule at src/isa/x64/inst.isle line 2568.

3994

    return v4;

3995

3996

3997

// Generated as internal constructor for term x64_paddusb.

3998

pub fn constructor_x64_paddusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

3999

    let v5 = C::use_avx_simd(ctx);

4000

    if v5 == true {

4001

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4002

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddusb, arg0, v7);

4003

        // Rule at src/isa/x64/inst.isle line 2578.

4004

        return v8;

4005

4006

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4007

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddusb, arg0, v3);

4008

    // Rule at src/isa/x64/inst.isle line 2576.

4009

    return v4;

4010

4011

4012

// Generated as internal constructor for term x64_paddusw.

4013

pub fn constructor_x64_paddusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4014

    let v5 = C::use_avx_simd(ctx);

4015

    if v5 == true {

4016

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4017

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddusw, arg0, v7);

4018

        // Rule at src/isa/x64/inst.isle line 2586.

4019

        return v8;

4020

4021

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4022

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddusw, arg0, v3);

4023

    // Rule at src/isa/x64/inst.isle line 2584.

4024

    return v4;

4025

4026

4027

// Generated as internal constructor for term x64_psubb.

4028

pub fn constructor_x64_psubb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4029

    let v5 = C::use_avx_simd(ctx);

4030

    if v5 == true {

4031

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4032

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubb, arg0, v7);

4033

        // Rule at src/isa/x64/inst.isle line 2594.

4034

        return v8;

4035

4036

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4037

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubb, arg0, v3);

4038

    // Rule at src/isa/x64/inst.isle line 2592.

4039

    return v4;

4040

4041

4042

// Generated as internal constructor for term x64_psubw.

4043

pub fn constructor_x64_psubw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4044

    let v5 = C::use_avx_simd(ctx);

4045

    if v5 == true {

4046

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4047

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubw, arg0, v7);

4048

        // Rule at src/isa/x64/inst.isle line 2602.

4049

        return v8;

4050

4051

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4052

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubw, arg0, v3);

4053

    // Rule at src/isa/x64/inst.isle line 2600.

4054

    return v4;

4055

4056

4057

// Generated as internal constructor for term x64_psubd.

4058

pub fn constructor_x64_psubd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4059

    let v5 = C::use_avx_simd(ctx);

4060

    if v5 == true {

4061

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4062

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubd, arg0, v7);

4063

        // Rule at src/isa/x64/inst.isle line 2610.

4064

        return v8;

4065

4066

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4067

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubd, arg0, v3);

4068

    // Rule at src/isa/x64/inst.isle line 2608.

4069

    return v4;

4070

4071

4072

// Generated as internal constructor for term x64_psubq.

4073

pub fn constructor_x64_psubq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4074

    let v5 = C::use_avx_simd(ctx);

4075

    if v5 == true {

4076

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4077

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubq, arg0, v7);

4078

        // Rule at src/isa/x64/inst.isle line 2618.

4079

        return v8;

4080

4081

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4082

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubq, arg0, v3);

4083

    // Rule at src/isa/x64/inst.isle line 2616.

4084

    return v4;

4085

4086

4087

// Generated as internal constructor for term x64_psubsb.

4088

pub fn constructor_x64_psubsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4089

    let v5 = C::use_avx_simd(ctx);

4090

    if v5 == true {

4091

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4092

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubsb, arg0, v7);

4093

        // Rule at src/isa/x64/inst.isle line 2626.

4094

        return v8;

4095

4096

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4097

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubsb, arg0, v3);

4098

    // Rule at src/isa/x64/inst.isle line 2624.

4099

    return v4;

4100

4101

4102

// Generated as internal constructor for term x64_psubsw.

4103

pub fn constructor_x64_psubsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4104

    let v5 = C::use_avx_simd(ctx);

4105

    if v5 == true {

4106

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4107

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubsw, arg0, v7);

4108

        // Rule at src/isa/x64/inst.isle line 2634.

4109

        return v8;

4110

4111

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4112

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubsw, arg0, v3);

4113

    // Rule at src/isa/x64/inst.isle line 2632.

4114

    return v4;

4115

4116

4117

// Generated as internal constructor for term x64_psubusb.

4118

pub fn constructor_x64_psubusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4119

    let v5 = C::use_avx_simd(ctx);

4120

    if v5 == true {

4121

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4122

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubusb, arg0, v7);

4123

        // Rule at src/isa/x64/inst.isle line 2642.

4124

        return v8;

4125

4126

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4127

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubusb, arg0, v3);

4128

    // Rule at src/isa/x64/inst.isle line 2640.

4129

    return v4;

4130

4131

4132

// Generated as internal constructor for term x64_psubusw.

4133

pub fn constructor_x64_psubusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4134

    let v5 = C::use_avx_simd(ctx);

4135

    if v5 == true {

4136

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4137

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubusw, arg0, v7);

4138

        // Rule at src/isa/x64/inst.isle line 2650.

4139

        return v8;

4140

4141

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4142

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubusw, arg0, v3);

4143

    // Rule at src/isa/x64/inst.isle line 2648.

4144

    return v4;

4145

4146

4147

// Generated as internal constructor for term x64_pavgb.

4148

pub fn constructor_x64_pavgb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4149

    let v5 = C::use_avx_simd(ctx);

4150

    if v5 == true {

4151

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4152

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpavgb, arg0, v7);

4153

        // Rule at src/isa/x64/inst.isle line 2658.

4154

        return v8;

4155

4156

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4157

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pavgb, arg0, v3);

4158

    // Rule at src/isa/x64/inst.isle line 2656.

4159

    return v4;

4160

4161

4162

// Generated as internal constructor for term x64_pavgw.

4163

pub fn constructor_x64_pavgw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4164

    let v5 = C::use_avx_simd(ctx);

4165

    if v5 == true {

4166

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4167

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpavgw, arg0, v7);

4168

        // Rule at src/isa/x64/inst.isle line 2666.

4169

        return v8;

4170

4171

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4172

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pavgw, arg0, v3);

4173

    // Rule at src/isa/x64/inst.isle line 2664.

4174

    return v4;

4175

4176

4177

// Generated as internal constructor for term x64_pand.

4178

pub fn constructor_x64_pand<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4179

    let v5 = C::use_avx_simd(ctx);

4180

    if v5 == true {

4181

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4182

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpand, arg0, v7);

4183

        // Rule at src/isa/x64/inst.isle line 2674.

4184

        return v8;

4185

4186

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4187

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pand, arg0, v3);

4188

    // Rule at src/isa/x64/inst.isle line 2672.

4189

    return v4;

4190

4191

4192

// Generated as internal constructor for term x64_andps.

4193

pub fn constructor_x64_andps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4194

    let v5 = C::use_avx_simd(ctx);

4195

    if v5 == true {

4196

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4197

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vandps, arg0, v7);

4198

        // Rule at src/isa/x64/inst.isle line 2682.

4199

        return v8;

4200

4201

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4202

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Andps, arg0, v3);

4203

    // Rule at src/isa/x64/inst.isle line 2680.

4204

    return v4;

4205

4206

4207

// Generated as internal constructor for term x64_andpd.

4208

pub fn constructor_x64_andpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4209

    let v5 = C::use_avx_simd(ctx);

4210

    if v5 == true {

4211

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4212

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vandpd, arg0, v7);

4213

        // Rule at src/isa/x64/inst.isle line 2690.

4214

        return v8;

4215

4216

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4217

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Andpd, arg0, v3);

4218

    // Rule at src/isa/x64/inst.isle line 2688.

4219

    return v4;

4220

4221

4222

// Generated as internal constructor for term x64_por.

4223

pub fn constructor_x64_por<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4224

    let v5 = C::use_avx_simd(ctx);

4225

    if v5 == true {

4226

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4227

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpor, arg0, v7);

4228

        // Rule at src/isa/x64/inst.isle line 2698.

4229

        return v8;

4230

4231

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4232

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Por, arg0, v3);

4233

    // Rule at src/isa/x64/inst.isle line 2696.

4234

    return v4;

4235

4236

4237

// Generated as internal constructor for term x64_orps.

4238

pub fn constructor_x64_orps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4239

    let v5 = C::use_avx_simd(ctx);

4240

    if v5 == true {

4241

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4242

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vorps, arg0, v7);

4243

        // Rule at src/isa/x64/inst.isle line 2706.

4244

        return v8;

4245

4246

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4247

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Orps, arg0, v3);

4248

    // Rule at src/isa/x64/inst.isle line 2704.

4249

    return v4;

4250

4251

4252

// Generated as internal constructor for term x64_orpd.

4253

pub fn constructor_x64_orpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4254

    let v5 = C::use_avx_simd(ctx);

4255

    if v5 == true {

4256

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4257

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vorpd, arg0, v7);

4258

        // Rule at src/isa/x64/inst.isle line 2714.

4259

        return v8;

4260

4261

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4262

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Orpd, arg0, v3);

4263

    // Rule at src/isa/x64/inst.isle line 2712.

4264

    return v4;

4265

4266

4267

// Generated as internal constructor for term x64_pxor.

4268

pub fn constructor_x64_pxor<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4269

    let v5 = C::use_avx_simd(ctx);

4270

    if v5 == true {

4271

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4272

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpxor, arg0, v7);

4273

        // Rule at src/isa/x64/inst.isle line 2722.

4274

        return v8;

4275

4276

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4277

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pxor, arg0, v3);

4278

    // Rule at src/isa/x64/inst.isle line 2720.

4279

    return v4;

4280

4281

4282

// Generated as internal constructor for term x64_xorps.

4283

pub fn constructor_x64_xorps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4284

    let v5 = C::use_avx_simd(ctx);

4285

    if v5 == true {

4286

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4287

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vxorps, arg0, v7);

4288

        // Rule at src/isa/x64/inst.isle line 2730.

4289

        return v8;

4290

4291

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4292

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Xorps, arg0, v3);

4293

    // Rule at src/isa/x64/inst.isle line 2728.

4294

    return v4;

4295

4296

4297

// Generated as internal constructor for term x64_xorpd.

4298

pub fn constructor_x64_xorpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4299

    let v5 = C::use_avx_simd(ctx);

4300

    if v5 == true {

4301

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4302

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vxorpd, arg0, v7);

4303

        // Rule at src/isa/x64/inst.isle line 2738.

4304

        return v8;

4305

4306

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4307

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Xorpd, arg0, v3);

4308

    // Rule at src/isa/x64/inst.isle line 2736.

4309

    return v4;

4310

4311

4312

// Generated as internal constructor for term x64_pmullw.

4313

pub fn constructor_x64_pmullw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4314

    let v5 = C::use_avx_simd(ctx);

4315

    if v5 == true {

4316

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4317

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmullw, arg0, v7);

4318

        // Rule at src/isa/x64/inst.isle line 2746.

4319

        return v8;

4320

4321

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4322

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmullw, arg0, v3);

4323

    // Rule at src/isa/x64/inst.isle line 2744.

4324

    return v4;

4325

4326

4327

// Generated as internal constructor for term x64_pmulld.

4328

pub fn constructor_x64_pmulld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4329

    let v5 = C::use_avx_simd(ctx);

4330

    if v5 == true {

4331

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4332

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmulld, arg0, v7);

4333

        // Rule at src/isa/x64/inst.isle line 2754.

4334

        return v8;

4335

4336

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4337

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmulld, arg0, v3);

4338

    // Rule at src/isa/x64/inst.isle line 2752.

4339

    return v4;

4340

4341

4342

// Generated as internal constructor for term x64_pmulhw.

4343

pub fn constructor_x64_pmulhw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4344

    let v5 = C::use_avx_simd(ctx);

4345

    if v5 == true {

4346

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4347

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmulhw, arg0, v7);

4348

        // Rule at src/isa/x64/inst.isle line 2762.

4349

        return v8;

4350

4351

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4352

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmulhw, arg0, v3);

4353

    // Rule at src/isa/x64/inst.isle line 2760.

4354

    return v4;

4355

4356

4357

// Generated as internal constructor for term x64_pmulhrsw.

4358

pub fn constructor_x64_pmulhrsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4359

    let v5 = C::use_avx_simd(ctx);

4360

    if v5 == true {

4361

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4362

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmulhrsw, arg0, v7);

4363

        // Rule at src/isa/x64/inst.isle line 2770.

4364

        return v8;

4365

4366

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4367

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmulhrsw, arg0, v3);

4368

    // Rule at src/isa/x64/inst.isle line 2768.

4369

    return v4;

4370

4371

4372

// Generated as internal constructor for term x64_pmulhuw.

4373

pub fn constructor_x64_pmulhuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4374

    let v5 = C::use_avx_simd(ctx);

4375

    if v5 == true {

4376

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4377

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmulhuw, arg0, v7);

4378

        // Rule at src/isa/x64/inst.isle line 2778.

4379

        return v8;

4380

4381

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4382

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmulhuw, arg0, v3);

4383

    // Rule at src/isa/x64/inst.isle line 2776.

4384

    return v4;

4385

4386

4387

// Generated as internal constructor for term x64_pmuldq.

4388

pub fn constructor_x64_pmuldq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4389

    let v5 = C::use_avx_simd(ctx);

4390

    if v5 == true {

4391

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4392

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmuldq, arg0, v7);

4393

        // Rule at src/isa/x64/inst.isle line 2786.

4394

        return v8;

4395

4396

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4397

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmuldq, arg0, v3);

4398

    // Rule at src/isa/x64/inst.isle line 2784.

4399

    return v4;

4400

4401

4402

// Generated as internal constructor for term x64_pmuludq.

4403

pub fn constructor_x64_pmuludq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4404

    let v5 = C::use_avx_simd(ctx);

4405

    if v5 == true {

4406

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4407

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmuludq, arg0, v7);

4408

        // Rule at src/isa/x64/inst.isle line 2794.

4409

        return v8;

4410

4411

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4412

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmuludq, arg0, v3);

4413

    // Rule at src/isa/x64/inst.isle line 2792.

4414

    return v4;

4415

4416

4417

// Generated as internal constructor for term x64_punpckhwd.

4418

pub fn constructor_x64_punpckhwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4419

    let v5 = C::use_avx_simd(ctx);

4420

    if v5 == true {

4421

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4422

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpckhwd, arg0, v7);

4423

        // Rule at src/isa/x64/inst.isle line 2802.

4424

        return v8;

4425

4426

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4427

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpckhwd, arg0, v3);

4428

    // Rule at src/isa/x64/inst.isle line 2800.

4429

    return v4;

4430

4431

4432

// Generated as internal constructor for term x64_punpcklwd.

4433

pub fn constructor_x64_punpcklwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4434

    let v5 = C::use_avx_simd(ctx);

4435

    if v5 == true {

4436

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4437

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpcklwd, arg0, v7);

4438

        // Rule at src/isa/x64/inst.isle line 2810.

4439

        return v8;

4440

4441

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4442

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpcklwd, arg0, v3);

4443

    // Rule at src/isa/x64/inst.isle line 2808.

4444

    return v4;

4445

4446

4447

// Generated as internal constructor for term x64_punpckldq.

4448

pub fn constructor_x64_punpckldq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4449

    let v5 = C::use_avx_simd(ctx);

4450

    if v5 == true {

4451

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4452

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpckldq, arg0, v7);

4453

        // Rule at src/isa/x64/inst.isle line 2818.

4454

        return v8;

4455

4456

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4457

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpckldq, arg0, v3);

4458

    // Rule at src/isa/x64/inst.isle line 2816.

4459

    return v4;

4460

4461

4462

// Generated as internal constructor for term x64_punpckhdq.

4463

pub fn constructor_x64_punpckhdq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4464

    let v5 = C::use_avx_simd(ctx);

4465

    if v5 == true {

4466

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4467

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpckhdq, arg0, v7);

4468

        // Rule at src/isa/x64/inst.isle line 2826.

4469

        return v8;

4470

4471

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4472

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpckhdq, arg0, v3);

4473

    // Rule at src/isa/x64/inst.isle line 2824.

4474

    return v4;

4475

4476

4477

// Generated as internal constructor for term x64_punpcklqdq.

4478

pub fn constructor_x64_punpcklqdq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4479

    let v5 = C::use_avx_simd(ctx);

4480

    if v5 == true {

4481

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4482

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpcklqdq, arg0, v7);

4483

        // Rule at src/isa/x64/inst.isle line 2834.

4484

        return v8;

4485

4486

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4487

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpcklqdq, arg0, v3);

4488

    // Rule at src/isa/x64/inst.isle line 2832.

4489

    return v4;

4490

4491

4492

// Generated as internal constructor for term x64_punpckhqdq.

4493

pub fn constructor_x64_punpckhqdq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4494

    let v5 = C::use_avx_simd(ctx);

4495

    if v5 == true {

4496

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4497

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpckhqdq, arg0, v7);

4498

        // Rule at src/isa/x64/inst.isle line 2842.

4499

        return v8;

4500

4501

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4502

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpckhqdq, arg0, v3);

4503

    // Rule at src/isa/x64/inst.isle line 2840.

4504

    return v4;

4505

4506

4507

// Generated as internal constructor for term x64_unpcklps.

4508

pub fn constructor_x64_unpcklps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4509

    let v5 = C::use_avx_simd(ctx);

4510

    if v5 == true {

4511

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4512

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vunpcklps, arg0, v7);

4513

        // Rule at src/isa/x64/inst.isle line 2850.

4514

        return v8;

4515

4516

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4517

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Unpcklps, arg0, v3);

4518

    // Rule at src/isa/x64/inst.isle line 2848.

4519

    return v4;

4520

4521

4522

// Generated as internal constructor for term x64_andnps.

4523

pub fn constructor_x64_andnps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4524

    let v5 = C::use_avx_simd(ctx);

4525

    if v5 == true {

4526

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4527

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vandnps, arg0, v7);

4528

        // Rule at src/isa/x64/inst.isle line 2858.

4529

        return v8;

4530

4531

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4532

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Andnps, arg0, v3);

4533

    // Rule at src/isa/x64/inst.isle line 2856.

4534

    return v4;

4535

4536

4537

// Generated as internal constructor for term x64_andnpd.

4538

pub fn constructor_x64_andnpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4539

    let v5 = C::use_avx_simd(ctx);

4540

    if v5 == true {

4541

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4542

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vandnpd, arg0, v7);

4543

        // Rule at src/isa/x64/inst.isle line 2866.

4544

        return v8;

4545

4546

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4547

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Andnpd, arg0, v3);

4548

    // Rule at src/isa/x64/inst.isle line 2864.

4549

    return v4;

4550

4551

4552

// Generated as internal constructor for term x64_pandn.

4553

pub fn constructor_x64_pandn<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4554

    let v5 = C::use_avx_simd(ctx);

4555

    if v5 == true {

4556

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4557

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpandn, arg0, v7);

4558

        // Rule at src/isa/x64/inst.isle line 2874.

4559

        return v8;

4560

4561

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4562

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pandn, arg0, v3);

4563

    // Rule at src/isa/x64/inst.isle line 2872.

4564

    return v4;

4565

4566

4567

// Generated as internal constructor for term x64_addss.

4568

pub fn constructor_x64_addss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4569

    let v4 = C::use_avx_simd(ctx);

4570

    if v4 == true {

4571

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4572

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vaddss, arg0, v6);

4573

        // Rule at src/isa/x64/inst.isle line 2882.

4574

        return v7;

4575

4576

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Addss, arg0, arg1);

4577

    // Rule at src/isa/x64/inst.isle line 2880.

4578

    return v3;

4579

4580

4581

// Generated as internal constructor for term x64_addsd.

4582

pub fn constructor_x64_addsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4583

    let v4 = C::use_avx_simd(ctx);

4584

    if v4 == true {

4585

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4586

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vaddsd, arg0, v6);

4587

        // Rule at src/isa/x64/inst.isle line 2890.

4588

        return v7;

4589

4590

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Addsd, arg0, arg1);

4591

    // Rule at src/isa/x64/inst.isle line 2888.

4592

    return v3;

4593

4594

4595

// Generated as internal constructor for term x64_addps.

4596

pub fn constructor_x64_addps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4597

    let v5 = C::use_avx_simd(ctx);

4598

    if v5 == true {

4599

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4600

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vaddps, arg0, v7);

4601

        // Rule at src/isa/x64/inst.isle line 2898.

4602

        return v8;

4603

4604

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4605

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Addps, arg0, v3);

4606

    // Rule at src/isa/x64/inst.isle line 2896.

4607

    return v4;

4608

4609

4610

// Generated as internal constructor for term x64_addpd.

4611

pub fn constructor_x64_addpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4612

    let v5 = C::use_avx_simd(ctx);

4613

    if v5 == true {

4614

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4615

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vaddpd, arg0, v7);

4616

        // Rule at src/isa/x64/inst.isle line 2906.

4617

        return v8;

4618

4619

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4620

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Addpd, arg0, v3);

4621

    // Rule at src/isa/x64/inst.isle line 2904.

4622

    return v4;

4623

4624

4625

// Generated as internal constructor for term x64_subss.

4626

pub fn constructor_x64_subss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4627

    let v4 = C::use_avx_simd(ctx);

4628

    if v4 == true {

4629

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4630

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vsubss, arg0, v6);

4631

        // Rule at src/isa/x64/inst.isle line 2914.

4632

        return v7;

4633

4634

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Subss, arg0, arg1);

4635

    // Rule at src/isa/x64/inst.isle line 2912.

4636

    return v3;

4637

4638

4639

// Generated as internal constructor for term x64_subsd.

4640

pub fn constructor_x64_subsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4641

    let v4 = C::use_avx_simd(ctx);

4642

    if v4 == true {

4643

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4644

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vsubsd, arg0, v6);

4645

        // Rule at src/isa/x64/inst.isle line 2922.

4646

        return v7;

4647

4648

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Subsd, arg0, arg1);

4649

    // Rule at src/isa/x64/inst.isle line 2920.

4650

    return v3;

4651

4652

4653

// Generated as internal constructor for term x64_subps.

4654

pub fn constructor_x64_subps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4655

    let v5 = C::use_avx_simd(ctx);

4656

    if v5 == true {

4657

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4658

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vsubps, arg0, v7);

4659

        // Rule at src/isa/x64/inst.isle line 2930.

4660

        return v8;

4661

4662

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4663

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Subps, arg0, v3);

4664

    // Rule at src/isa/x64/inst.isle line 2928.

4665

    return v4;

4666

4667

4668

// Generated as internal constructor for term x64_subpd.

4669

pub fn constructor_x64_subpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4670

    let v5 = C::use_avx_simd(ctx);

4671

    if v5 == true {

4672

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4673

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vsubpd, arg0, v7);

4674

        // Rule at src/isa/x64/inst.isle line 2938.

4675

        return v8;

4676

4677

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4678

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Subpd, arg0, v3);

4679

    // Rule at src/isa/x64/inst.isle line 2936.

4680

    return v4;

4681

4682

4683

// Generated as internal constructor for term x64_mulss.

4684

pub fn constructor_x64_mulss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4685

    let v4 = C::use_avx_simd(ctx);

4686

    if v4 == true {

4687

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4688

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmulss, arg0, v6);

4689

        // Rule at src/isa/x64/inst.isle line 2946.

4690

        return v7;

4691

4692

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Mulss, arg0, arg1);

4693

    // Rule at src/isa/x64/inst.isle line 2944.

4694

    return v3;

4695

4696

4697

// Generated as internal constructor for term x64_mulsd.

4698

pub fn constructor_x64_mulsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4699

    let v4 = C::use_avx_simd(ctx);

4700

    if v4 == true {

4701

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4702

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmulsd, arg0, v6);

4703

        // Rule at src/isa/x64/inst.isle line 2954.

4704

        return v7;

4705

4706

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Mulsd, arg0, arg1);

4707

    // Rule at src/isa/x64/inst.isle line 2952.

4708

    return v3;

4709

4710

4711

// Generated as internal constructor for term x64_mulps.

4712

pub fn constructor_x64_mulps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4713

    let v5 = C::use_avx_simd(ctx);

4714

    if v5 == true {

4715

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4716

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmulps, arg0, v7);

4717

        // Rule at src/isa/x64/inst.isle line 2962.

4718

        return v8;

4719

4720

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4721

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Mulps, arg0, v3);

4722

    // Rule at src/isa/x64/inst.isle line 2960.

4723

    return v4;

4724

4725

4726

// Generated as internal constructor for term x64_mulpd.

4727

pub fn constructor_x64_mulpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4728

    let v5 = C::use_avx_simd(ctx);

4729

    if v5 == true {

4730

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4731

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmulpd, arg0, v7);

4732

        // Rule at src/isa/x64/inst.isle line 2970.

4733

        return v8;

4734

4735

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4736

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Mulpd, arg0, v3);

4737

    // Rule at src/isa/x64/inst.isle line 2968.

4738

    return v4;

4739

4740

4741

// Generated as internal constructor for term x64_divss.

4742

pub fn constructor_x64_divss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4743

    let v4 = C::use_avx_simd(ctx);

4744

    if v4 == true {

4745

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4746

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vdivss, arg0, v6);

4747

        // Rule at src/isa/x64/inst.isle line 2978.

4748

        return v7;

4749

4750

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Divss, arg0, arg1);

4751

    // Rule at src/isa/x64/inst.isle line 2976.

4752

    return v3;

4753

4754

4755

// Generated as internal constructor for term x64_divsd.

4756

pub fn constructor_x64_divsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4757

    let v4 = C::use_avx_simd(ctx);

4758

    if v4 == true {

4759

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4760

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vdivsd, arg0, v6);

4761

        // Rule at src/isa/x64/inst.isle line 2986.

4762

        return v7;

4763

4764

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Divsd, arg0, arg1);

4765

    // Rule at src/isa/x64/inst.isle line 2984.

4766

    return v3;

4767

4768

4769

// Generated as internal constructor for term x64_divps.

4770

pub fn constructor_x64_divps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4771

    let v5 = C::use_avx_simd(ctx);

4772

    if v5 == true {

4773

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4774

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vdivps, arg0, v7);

4775

        // Rule at src/isa/x64/inst.isle line 2994.

4776

        return v8;

4777

4778

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4779

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Divps, arg0, v3);

4780

    // Rule at src/isa/x64/inst.isle line 2992.

4781

    return v4;

4782

4783

4784

// Generated as internal constructor for term x64_divpd.

4785

pub fn constructor_x64_divpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

4786

    let v5 = C::use_avx_simd(ctx);

4787

    if v5 == true {

4788

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

4789

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vdivpd, arg0, v7);

4790

        // Rule at src/isa/x64/inst.isle line 3002.

4791

        return v8;

4792

4793

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4794

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Divpd, arg0, v3);

4795

    // Rule at src/isa/x64/inst.isle line 3000.

4796

    return v4;

4797

4798

4799

// Generated as internal constructor for term xmm_rm_r_blend.

4800

pub fn constructor_xmm_rm_r_blend<C: Context>(

4801

    ctx: &mut C,

4802

    arg0: &SseOpcode,

4803

    arg1: Xmm,

4804

    arg2: &XmmMemAligned,

4805

    arg3: Xmm,

4806

) -> Xmm {

4807

    let v4 = C::temp_writable_xmm(ctx);

4808

    let v5 = MInst::XmmRmRBlend {

4809

        op: arg0.clone(),

4810

        src1: arg1,

4811

        src2: arg2.clone(),

4812

        mask: arg3,

4813

        dst: v4,

4814

};

4815

    let v6 = C::emit(ctx, &v5);

4816

    let v7 = C::writable_xmm_to_xmm(ctx, v4);

4817

    // Rule at src/isa/x64/inst.isle line 3008.

4818

    return v7;

4819

4820

4821

// Generated as internal constructor for term xmm_rmr_blend_vex.

4822

pub fn constructor_xmm_rmr_blend_vex<C: Context>(

4823

    ctx: &mut C,

4824

    arg0: &AvxOpcode,

4825

    arg1: Xmm,

4826

    arg2: &XmmMem,

4827

    arg3: Xmm,

4828

) -> Xmm {

4829

    let v4 = C::temp_writable_xmm(ctx);

4830

    let v5 = MInst::XmmRmRBlendVex {

4831

        op: arg0.clone(),

4832

        src1: arg1,

4833

        src2: arg2.clone(),

4834

        mask: arg3,

4835

        dst: v4,

4836

};

4837

    let v6 = C::emit(ctx, &v5);

4838

    let v7 = C::writable_xmm_to_xmm(ctx, v4);

4839

    // Rule at src/isa/x64/inst.isle line 3015.

4840

    return v7;

4841

4842

4843

// Generated as internal constructor for term xmm_unary_rm_r_vex.

4844

pub fn constructor_xmm_unary_rm_r_vex<C: Context>(

4845

    ctx: &mut C,

4846

    arg0: &AvxOpcode,

4847

    arg1: &XmmMem,

4848

) -> Xmm {

4849

    let v2 = C::temp_writable_xmm(ctx);

4850

    let v3 = MInst::XmmUnaryRmRVex {

4851

        op: arg0.clone(),

4852

        src: arg1.clone(),

4853

        dst: v2,

4854

};

4855

    let v4 = C::emit(ctx, &v3);

4856

    let v5 = C::writable_xmm_to_xmm(ctx, v2);

4857

    // Rule at src/isa/x64/inst.isle line 3022.

4858

    return v5;

4859

4860

4861

// Generated as internal constructor for term xmm_unary_rm_r_imm_vex.

4862

pub fn constructor_xmm_unary_rm_r_imm_vex<C: Context>(

4863

    ctx: &mut C,

4864

    arg0: &AvxOpcode,

4865

    arg1: &XmmMem,

4866

    arg2: u8,

4867

) -> Xmm {

4868

    let v3 = C::temp_writable_xmm(ctx);

4869

    let v4 = MInst::XmmUnaryRmRImmVex {

4870

        op: arg0.clone(),

4871

        src: arg1.clone(),

4872

        dst: v3,

4873

        imm: arg2,

4874

};

4875

    let v5 = C::emit(ctx, &v4);

4876

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

4877

    // Rule at src/isa/x64/inst.isle line 3029.

4878

    return v6;

4879

4880

4881

// Generated as internal constructor for term x64_blend.

4882

pub fn constructor_x64_blend<C: Context>(

4883

    ctx: &mut C,

4884

    arg0: Type,

4885

    arg1: Xmm,

4886

    arg2: &XmmMem,

4887

    arg3: Xmm,

4888

) -> Xmm {

4889

    match arg0 {

4890

        F32X4 => {

4891

            let v4 = constructor_x64_blendvps(ctx, arg3, arg2, arg1);

4892

            // Rule at src/isa/x64/inst.isle line 3036.

4893

            return v4;

4894

4895

        F64X2 => {

4896

            let v5 = constructor_x64_blendvpd(ctx, arg3, arg2, arg1);

4897

            // Rule at src/isa/x64/inst.isle line 3037.

4898

            return v5;

4899

4900

        _ => {}

4901

4902

    let v6 = C::multi_lane(ctx, arg0);

4903

    if let Some(v7) = v6 {

4904

        let v10 = constructor_x64_pblendvb(ctx, arg3, arg2, arg1);

4905

        // Rule at src/isa/x64/inst.isle line 3038.

4906

        return v10;

4907

4908

    unreachable!(

4909

        "no rule matched for term {} at {}; should it be partial?",

4910

        "x64_blend", "src/isa/x64/inst.isle line 3035"

4911

4912

4913

4914

// Generated as internal constructor for term x64_blendvpd.

4915

pub fn constructor_x64_blendvpd<C: Context>(

4916

    ctx: &mut C,

4917

    arg0: Xmm,

4918

    arg1: &XmmMem,

4919

    arg2: Xmm,

4920

) -> Xmm {

4921

    let v6 = C::use_avx_simd(ctx);

4922

    if v6 == true {

4923

        let v8 = constructor_xmm_rmr_blend_vex(ctx, &AvxOpcode::Vblendvpd, arg0, arg1, arg2);

4924

        // Rule at src/isa/x64/inst.isle line 3044.

4925

        return v8;

4926

4927

    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4928

    let v5 = constructor_xmm_rm_r_blend(ctx, &SseOpcode::Blendvpd, arg0, v4, arg2);

4929

    // Rule at src/isa/x64/inst.isle line 3042.

4930

    return v5;

4931

4932

4933

// Generated as internal constructor for term x64_blendvps.

4934

pub fn constructor_x64_blendvps<C: Context>(

4935

    ctx: &mut C,

4936

    arg0: Xmm,

4937

    arg1: &XmmMem,

4938

    arg2: Xmm,

4939

) -> Xmm {

4940

    let v6 = C::use_avx_simd(ctx);

4941

    if v6 == true {

4942

        let v8 = constructor_xmm_rmr_blend_vex(ctx, &AvxOpcode::Vblendvps, arg0, arg1, arg2);

4943

        // Rule at src/isa/x64/inst.isle line 3052.

4944

        return v8;

4945

4946

    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4947

    let v5 = constructor_xmm_rm_r_blend(ctx, &SseOpcode::Blendvps, arg0, v4, arg2);

4948

    // Rule at src/isa/x64/inst.isle line 3050.

4949

    return v5;

4950

4951

4952

// Generated as internal constructor for term x64_pblendvb.

4953

pub fn constructor_x64_pblendvb<C: Context>(

4954

    ctx: &mut C,

4955

    arg0: Xmm,

4956

    arg1: &XmmMem,

4957

    arg2: Xmm,

4958

) -> Xmm {

4959

    let v6 = C::use_avx_simd(ctx);

4960

    if v6 == true {

4961

        let v8 = constructor_xmm_rmr_blend_vex(ctx, &AvxOpcode::Vpblendvb, arg0, arg1, arg2);

4962

        // Rule at src/isa/x64/inst.isle line 3060.

4963

        return v8;

4964

4965

    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

4966

    let v5 = constructor_xmm_rm_r_blend(ctx, &SseOpcode::Pblendvb, arg0, v4, arg2);

4967

    // Rule at src/isa/x64/inst.isle line 3058.

4968

    return v5;

4969

4970

4971

// Generated as internal constructor for term x64_pblendw.

4972

pub fn constructor_x64_pblendw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> Xmm {

4973

    let v8 = C::use_avx_simd(ctx);

4974

    if v8 == true {

4975

        let v10 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vpblendw, arg0, arg1, arg2);

4976

        // Rule at src/isa/x64/inst.isle line 3068.

4977

        return v10;

4978

4979

    let v4 = C::xmm_to_reg(ctx, arg0);

4980

    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);

4981

    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Pblendw, v4, v5, arg2, &OperandSize::Size32);

4982

    // Rule at src/isa/x64/inst.isle line 3066.

4983

    return v7;

4984

4985

4986

// Generated as internal constructor for term x64_movsd_regmove.

4987

pub fn constructor_x64_movsd_regmove<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Xmm {

4988

    let v5 = C::use_avx_simd(ctx);

4989

    if v5 == true {

4990

        let v7 = &C::xmm_to_xmm_mem_imm(ctx, arg1);

4991

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmovsd, arg0, v7);

4992

        // Rule at src/isa/x64/inst.isle line 3083.

4993

        return v8;

4994

4995

    let v3 = &C::xmm_to_xmm_mem(ctx, arg1);

4996

    let v4 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Movsd, arg0, v3);

4997

    // Rule at src/isa/x64/inst.isle line 3081.

4998

    return v4;

4999

5000

5001

// Generated as internal constructor for term x64_movlhps.

5002

pub fn constructor_x64_movlhps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5003

    let v5 = C::use_avx_simd(ctx);

5004

    if v5 == true {

5005

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5006

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmovlhps, arg0, v7);

5007

        // Rule at src/isa/x64/inst.isle line 3091.

5008

        return v8;

5009

5010

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5011

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Movlhps, arg0, v3);

5012

    // Rule at src/isa/x64/inst.isle line 3089.

5013

    return v4;

5014

5015

5016

// Generated as internal constructor for term x64_pmaxs.

5017

pub fn constructor_x64_pmaxs<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {

5018

    match arg0 {

5019

        I8X16 => {

5020

            let v3 = constructor_x64_pmaxsb(ctx, arg1, arg2);

5021

            // Rule at src/isa/x64/inst.isle line 3097.

5022

            return v3;

5023

5024

        I16X8 => {

5025

            let v4 = constructor_x64_pmaxsw(ctx, arg1, arg2);

5026

            // Rule at src/isa/x64/inst.isle line 3098.

5027

            return v4;

5028

5029

        I32X4 => {

5030

            let v5 = constructor_x64_pmaxsd(ctx, arg1, arg2);

5031

            // Rule at src/isa/x64/inst.isle line 3099.

5032

            return v5;

5033

5034

        _ => {}

5035

5036

    unreachable!(

5037

        "no rule matched for term {} at {}; should it be partial?",

5038

        "x64_pmaxs", "src/isa/x64/inst.isle line 3096"

5039

5040

5041

5042

// Generated as internal constructor for term x64_pmaxsb.

5043

pub fn constructor_x64_pmaxsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5044

    let v5 = C::use_avx_simd(ctx);

5045

    if v5 == true {

5046

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5047

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxsb, arg0, v7);

5048

        // Rule at src/isa/x64/inst.isle line 3103.

5049

        return v8;

5050

5051

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5052

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxsb, arg0, v3);

5053

    // Rule at src/isa/x64/inst.isle line 3102.

5054

    return v4;

5055

5056

5057

// Generated as internal constructor for term x64_pmaxsw.

5058

pub fn constructor_x64_pmaxsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5059

    let v5 = C::use_avx_simd(ctx);

5060

    if v5 == true {

5061

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5062

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxsw, arg0, v7);

5063

        // Rule at src/isa/x64/inst.isle line 3108.

5064

        return v8;

5065

5066

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5067

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxsw, arg0, v3);

5068

    // Rule at src/isa/x64/inst.isle line 3107.

5069

    return v4;

5070

5071

5072

// Generated as internal constructor for term x64_pmaxsd.

5073

pub fn constructor_x64_pmaxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5074

    let v5 = C::use_avx_simd(ctx);

5075

    if v5 == true {

5076

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5077

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxsd, arg0, v7);

5078

        // Rule at src/isa/x64/inst.isle line 3113.

5079

        return v8;

5080

5081

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5082

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxsd, arg0, v3);

5083

    // Rule at src/isa/x64/inst.isle line 3112.

5084

    return v4;

5085

5086

5087

// Generated as internal constructor for term x64_pmins.

5088

pub fn constructor_x64_pmins<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {

5089

    match arg0 {

5090

        I8X16 => {

5091

            let v3 = constructor_x64_pminsb(ctx, arg1, arg2);

5092

            // Rule at src/isa/x64/inst.isle line 3119.

5093

            return v3;

5094

5095

        I16X8 => {

5096

            let v4 = constructor_x64_pminsw(ctx, arg1, arg2);

5097

            // Rule at src/isa/x64/inst.isle line 3120.

5098

            return v4;

5099

5100

        I32X4 => {

5101

            let v5 = constructor_x64_pminsd(ctx, arg1, arg2);

5102

            // Rule at src/isa/x64/inst.isle line 3121.

5103

            return v5;

5104

5105

        _ => {}

5106

5107

    unreachable!(

5108

        "no rule matched for term {} at {}; should it be partial?",

5109

        "x64_pmins", "src/isa/x64/inst.isle line 3118"

5110

5111

5112

5113

// Generated as internal constructor for term x64_pminsb.

5114

pub fn constructor_x64_pminsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5115

    let v5 = C::use_avx_simd(ctx);

5116

    if v5 == true {

5117

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5118

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminsb, arg0, v7);

5119

        // Rule at src/isa/x64/inst.isle line 3125.

5120

        return v8;

5121

5122

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5123

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminsb, arg0, v3);

5124

    // Rule at src/isa/x64/inst.isle line 3124.

5125

    return v4;

5126

5127

5128

// Generated as internal constructor for term x64_pminsw.

5129

pub fn constructor_x64_pminsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5130

    let v5 = C::use_avx_simd(ctx);

5131

    if v5 == true {

5132

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5133

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminsw, arg0, v7);

5134

        // Rule at src/isa/x64/inst.isle line 3130.

5135

        return v8;

5136

5137

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5138

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminsw, arg0, v3);

5139

    // Rule at src/isa/x64/inst.isle line 3129.

5140

    return v4;

5141

5142

5143

// Generated as internal constructor for term x64_pminsd.

5144

pub fn constructor_x64_pminsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5145

    let v5 = C::use_avx_simd(ctx);

5146

    if v5 == true {

5147

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5148

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminsd, arg0, v7);

5149

        // Rule at src/isa/x64/inst.isle line 3135.

5150

        return v8;

5151

5152

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5153

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminsd, arg0, v3);

5154

    // Rule at src/isa/x64/inst.isle line 3134.

5155

    return v4;

5156

5157

5158

// Generated as internal constructor for term x64_pmaxu.

5159

pub fn constructor_x64_pmaxu<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {

5160

    match arg0 {

5161

        I8X16 => {

5162

            let v3 = constructor_x64_pmaxub(ctx, arg1, arg2);

5163

            // Rule at src/isa/x64/inst.isle line 3141.

5164

            return v3;

5165

5166

        I16X8 => {

5167

            let v4 = constructor_x64_pmaxuw(ctx, arg1, arg2);

5168

            // Rule at src/isa/x64/inst.isle line 3142.

5169

            return v4;

5170

5171

        I32X4 => {

5172

            let v5 = constructor_x64_pmaxud(ctx, arg1, arg2);

5173

            // Rule at src/isa/x64/inst.isle line 3143.

5174

            return v5;

5175

5176

        _ => {}

5177

5178

    unreachable!(

5179

        "no rule matched for term {} at {}; should it be partial?",

5180

        "x64_pmaxu", "src/isa/x64/inst.isle line 3140"

5181

5182

5183

5184

// Generated as internal constructor for term x64_pmaxub.

5185

pub fn constructor_x64_pmaxub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5186

    let v5 = C::use_avx_simd(ctx);

5187

    if v5 == true {

5188

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5189

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxub, arg0, v7);

5190

        // Rule at src/isa/x64/inst.isle line 3147.

5191

        return v8;

5192

5193

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5194

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxub, arg0, v3);

5195

    // Rule at src/isa/x64/inst.isle line 3146.

5196

    return v4;

5197

5198

5199

// Generated as internal constructor for term x64_pmaxuw.

5200

pub fn constructor_x64_pmaxuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5201

    let v5 = C::use_avx_simd(ctx);

5202

    if v5 == true {

5203

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5204

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxuw, arg0, v7);

5205

        // Rule at src/isa/x64/inst.isle line 3152.

5206

        return v8;

5207

5208

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5209

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxuw, arg0, v3);

5210

    // Rule at src/isa/x64/inst.isle line 3151.

5211

    return v4;

5212

5213

5214

// Generated as internal constructor for term x64_pmaxud.

5215

pub fn constructor_x64_pmaxud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5216

    let v5 = C::use_avx_simd(ctx);

5217

    if v5 == true {

5218

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5219

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxud, arg0, v7);

5220

        // Rule at src/isa/x64/inst.isle line 3157.

5221

        return v8;

5222

5223

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5224

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxud, arg0, v3);

5225

    // Rule at src/isa/x64/inst.isle line 3156.

5226

    return v4;

5227

5228

5229

// Generated as internal constructor for term x64_pminu.

5230

pub fn constructor_x64_pminu<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {

5231

    match arg0 {

5232

        I8X16 => {

5233

            let v3 = constructor_x64_pminub(ctx, arg1, arg2);

5234

            // Rule at src/isa/x64/inst.isle line 3163.

5235

            return v3;

5236

5237

        I16X8 => {

5238

            let v4 = constructor_x64_pminuw(ctx, arg1, arg2);

5239

            // Rule at src/isa/x64/inst.isle line 3164.

5240

            return v4;

5241

5242

        I32X4 => {

5243

            let v5 = constructor_x64_pminud(ctx, arg1, arg2);

5244

            // Rule at src/isa/x64/inst.isle line 3165.

5245

            return v5;

5246

5247

        _ => {}

5248

5249

    unreachable!(

5250

        "no rule matched for term {} at {}; should it be partial?",

5251

        "x64_pminu", "src/isa/x64/inst.isle line 3162"

5252

5253

5254

5255

// Generated as internal constructor for term x64_pminub.

5256

pub fn constructor_x64_pminub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5257

    let v5 = C::use_avx_simd(ctx);

5258

    if v5 == true {

5259

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5260

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminub, arg0, v7);

5261

        // Rule at src/isa/x64/inst.isle line 3169.

5262

        return v8;

5263

5264

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5265

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminub, arg0, v3);

5266

    // Rule at src/isa/x64/inst.isle line 3168.

5267

    return v4;

5268

5269

5270

// Generated as internal constructor for term x64_pminuw.

5271

pub fn constructor_x64_pminuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5272

    let v5 = C::use_avx_simd(ctx);

5273

    if v5 == true {

5274

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5275

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminuw, arg0, v7);

5276

        // Rule at src/isa/x64/inst.isle line 3174.

5277

        return v8;

5278

5279

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5280

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminuw, arg0, v3);

5281

    // Rule at src/isa/x64/inst.isle line 3173.

5282

    return v4;

5283

5284

5285

// Generated as internal constructor for term x64_pminud.

5286

pub fn constructor_x64_pminud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5287

    let v5 = C::use_avx_simd(ctx);

5288

    if v5 == true {

5289

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5290

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminud, arg0, v7);

5291

        // Rule at src/isa/x64/inst.isle line 3179.

5292

        return v8;

5293

5294

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5295

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminud, arg0, v3);

5296

    // Rule at src/isa/x64/inst.isle line 3178.

5297

    return v4;

5298

5299

5300

// Generated as internal constructor for term x64_punpcklbw.

5301

pub fn constructor_x64_punpcklbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5302

    let v5 = C::use_avx_simd(ctx);

5303

    if v5 == true {

5304

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5305

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpcklbw, arg0, v7);

5306

        // Rule at src/isa/x64/inst.isle line 3187.

5307

        return v8;

5308

5309

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5310

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpcklbw, arg0, v3);

5311

    // Rule at src/isa/x64/inst.isle line 3185.

5312

    return v4;

5313

5314

5315

// Generated as internal constructor for term x64_punpckhbw.

5316

pub fn constructor_x64_punpckhbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5317

    let v5 = C::use_avx_simd(ctx);

5318

    if v5 == true {

5319

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5320

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpckhbw, arg0, v7);

5321

        // Rule at src/isa/x64/inst.isle line 3195.

5322

        return v8;

5323

5324

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5325

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpckhbw, arg0, v3);

5326

    // Rule at src/isa/x64/inst.isle line 3193.

5327

    return v4;

5328

5329

5330

// Generated as internal constructor for term x64_packsswb.

5331

pub fn constructor_x64_packsswb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5332

    let v5 = C::use_avx_simd(ctx);

5333

    if v5 == true {

5334

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5335

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpacksswb, arg0, v7);

5336

        // Rule at src/isa/x64/inst.isle line 3203.

5337

        return v8;

5338

5339

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5340

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Packsswb, arg0, v3);

5341

    // Rule at src/isa/x64/inst.isle line 3201.

5342

    return v4;

5343

5344

5345

// Generated as internal constructor for term x64_packssdw.

5346

pub fn constructor_x64_packssdw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5347

    let v5 = C::use_avx_simd(ctx);

5348

    if v5 == true {

5349

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5350

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpackssdw, arg0, v7);

5351

        // Rule at src/isa/x64/inst.isle line 3211.

5352

        return v8;

5353

5354

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5355

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Packssdw, arg0, v3);

5356

    // Rule at src/isa/x64/inst.isle line 3209.

5357

    return v4;

5358

5359

5360

// Generated as internal constructor for term x64_packuswb.

5361

pub fn constructor_x64_packuswb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5362

    let v5 = C::use_avx_simd(ctx);

5363

    if v5 == true {

5364

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5365

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpackuswb, arg0, v7);

5366

        // Rule at src/isa/x64/inst.isle line 3219.

5367

        return v8;

5368

5369

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5370

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Packuswb, arg0, v3);

5371

    // Rule at src/isa/x64/inst.isle line 3217.

5372

    return v4;

5373

5374

5375

// Generated as internal constructor for term x64_packusdw.

5376

pub fn constructor_x64_packusdw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5377

    let v5 = C::use_avx_simd(ctx);

5378

    if v5 == true {

5379

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5380

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpackusdw, arg0, v7);

5381

        // Rule at src/isa/x64/inst.isle line 3227.

5382

        return v8;

5383

5384

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5385

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Packusdw, arg0, v3);

5386

    // Rule at src/isa/x64/inst.isle line 3225.

5387

    return v4;

5388

5389

5390

// Generated as internal constructor for term xmm_rm_r_imm.

5391

pub fn constructor_xmm_rm_r_imm<C: Context>(

5392

    ctx: &mut C,

5393

    arg0: &SseOpcode,

5394

    arg1: Reg,

5395

    arg2: &RegMem,

5396

    arg3: u8,

5397

    arg4: &OperandSize,

5398

) -> Xmm {

5399

    let v5 = C::temp_writable_xmm(ctx);

5400

    let v6 = C::writable_xmm_to_reg(ctx, v5);

5401

    let v7 = MInst::XmmRmRImm {

5402

        op: arg0.clone(),

5403

        src1: arg1,

5404

        src2: arg2.clone(),

5405

        dst: v6,

5406

        imm: arg3,

5407

        size: arg4.clone(),

5408

};

5409

    let v8 = C::emit(ctx, &v7);

5410

    let v9 = C::writable_xmm_to_xmm(ctx, v5);

5411

    // Rule at src/isa/x64/inst.isle line 3233.

5412

    return v9;

5413

5414

5415

// Generated as internal constructor for term x64_palignr.

5416

pub fn constructor_x64_palignr<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> Xmm {

5417

    let v8 = C::use_avx_simd(ctx);

5418

    if v8 == true {

5419

        let v10 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vpalignr, arg0, arg1, arg2);

5420

        // Rule at src/isa/x64/inst.isle line 3251.

5421

        return v10;

5422

5423

    let v4 = C::xmm_to_reg(ctx, arg0);

5424

    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);

5425

    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Palignr, v4, v5, arg2, &OperandSize::Size32);

5426

    // Rule at src/isa/x64/inst.isle line 3245.

5427

    return v7;

5428

5429

5430

// Generated as internal constructor for term x64_cmpp.

5431

pub fn constructor_x64_cmpp<C: Context>(

5432

    ctx: &mut C,

5433

    arg0: Type,

5434

    arg1: Xmm,

5435

    arg2: &XmmMem,

5436

    arg3: &FcmpImm,

5437

) -> Xmm {

5438

    match arg0 {

5439

        F32X4 => {

5440

            let v4 = constructor_x64_cmpps(ctx, arg1, arg2, arg3);

5441

            // Rule at src/isa/x64/inst.isle line 3257.

5442

            return v4;

5443

5444

        F64X2 => {

5445

            let v5 = constructor_x64_cmppd(ctx, arg1, arg2, arg3);

5446

            // Rule at src/isa/x64/inst.isle line 3258.

5447

            return v5;

5448

5449

        _ => {}

5450

5451

    unreachable!(

5452

        "no rule matched for term {} at {}; should it be partial?",

5453

        "x64_cmpp", "src/isa/x64/inst.isle line 3256"

5454

5455

5456

5457

// Generated as internal constructor for term x64_cmpps.

5458

pub fn constructor_x64_cmpps<C: Context>(

5459

    ctx: &mut C,

5460

    arg0: Xmm,

5461

    arg1: &XmmMem,

5462

    arg2: &FcmpImm,

5463

) -> Xmm {

5464

    let v9 = C::use_avx_simd(ctx);

5465

    if v9 == true {

5466

        let v11 = C::encode_fcmp_imm(ctx, arg2);

5467

        let v12 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vcmpps, arg0, arg1, v11);

5468

        // Rule at src/isa/x64/inst.isle line 3267.

5469

        return v12;

5470

5471

    let v4 = C::xmm_to_reg(ctx, arg0);

5472

    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);

5473

    let v6 = C::encode_fcmp_imm(ctx, arg2);

5474

    let v8 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Cmpps, v4, v5, v6, &OperandSize::Size32);

5475

    // Rule at src/isa/x64/inst.isle line 3261.

5476

    return v8;

5477

5478

5479

// Generated as internal constructor for term x64_cmppd.

5480

pub fn constructor_x64_cmppd<C: Context>(

5481

    ctx: &mut C,

5482

    arg0: Xmm,

5483

    arg1: &XmmMem,

5484

    arg2: &FcmpImm,

5485

) -> Xmm {

5486

    let v9 = C::use_avx_simd(ctx);

5487

    if v9 == true {

5488

        let v11 = C::encode_fcmp_imm(ctx, arg2);

5489

        let v12 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vcmppd, arg0, arg1, v11);

5490

        // Rule at src/isa/x64/inst.isle line 3284.

5491

        return v12;

5492

5493

    let v4 = C::xmm_to_reg(ctx, arg0);

5494

    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);

5495

    let v6 = C::encode_fcmp_imm(ctx, arg2);

5496

    let v8 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Cmppd, v4, v5, v6, &OperandSize::Size32);

5497

    // Rule at src/isa/x64/inst.isle line 3278.

5498

    return v8;

5499

5500

5501

// Generated as internal constructor for term x64_pinsrb.

5502

pub fn constructor_x64_pinsrb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &GprMem, arg2: u8) -> Xmm {

5503

    let v8 = C::use_avx_simd(ctx);

5504

    if v8 == true {

5505

        let v10 = constructor_xmm_vex_pinsr(ctx, &AvxOpcode::Vpinsrb, arg0, arg1, arg2);

5506

        // Rule at src/isa/x64/inst.isle line 3299.

5507

        return v10;

5508

5509

    let v4 = C::xmm_to_reg(ctx, arg0);

5510

    let v5 = &C::gpr_mem_to_reg_mem(ctx, arg1);

5511

    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Pinsrb, v4, v5, arg2, &OperandSize::Size32);

5512

    // Rule at src/isa/x64/inst.isle line 3293.

5513

    return v7;

5514

5515

5516

// Generated as internal constructor for term x64_pinsrw.

5517

pub fn constructor_x64_pinsrw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &GprMem, arg2: u8) -> Xmm {

5518

    let v8 = C::use_avx_simd(ctx);

5519

    if v8 == true {

5520

        let v10 = constructor_xmm_vex_pinsr(ctx, &AvxOpcode::Vpinsrw, arg0, arg1, arg2);

5521

        // Rule at src/isa/x64/inst.isle line 3311.

5522

        return v10;

5523

5524

    let v4 = C::xmm_to_reg(ctx, arg0);

5525

    let v5 = &C::gpr_mem_to_reg_mem(ctx, arg1);

5526

    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Pinsrw, v4, v5, arg2, &OperandSize::Size32);

5527

    // Rule at src/isa/x64/inst.isle line 3305.

5528

    return v7;

5529

5530

5531

// Generated as internal constructor for term x64_pinsrd.

5532

pub fn constructor_x64_pinsrd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &GprMem, arg2: u8) -> Xmm {

5533

    let v8 = C::use_avx_simd(ctx);

5534

    if v8 == true {

5535

        let v10 = constructor_xmm_vex_pinsr(ctx, &AvxOpcode::Vpinsrd, arg0, arg1, arg2);

5536

        // Rule at src/isa/x64/inst.isle line 3323.

5537

        return v10;

5538

5539

    let v4 = C::xmm_to_reg(ctx, arg0);

5540

    let v5 = &C::gpr_mem_to_reg_mem(ctx, arg1);

5541

    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Pinsrd, v4, v5, arg2, &OperandSize::Size32);

5542

    // Rule at src/isa/x64/inst.isle line 3317.

5543

    return v7;

5544

5545

5546

// Generated as internal constructor for term x64_pinsrq.

5547

pub fn constructor_x64_pinsrq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &GprMem, arg2: u8) -> Xmm {

5548

    let v8 = C::use_avx_simd(ctx);

5549

    if v8 == true {

5550

        let v10 = constructor_xmm_vex_pinsr(ctx, &AvxOpcode::Vpinsrq, arg0, arg1, arg2);

5551

        // Rule at src/isa/x64/inst.isle line 3335.

5552

        return v10;

5553

5554

    let v4 = C::xmm_to_reg(ctx, arg0);

5555

    let v5 = &C::gpr_mem_to_reg_mem(ctx, arg1);

5556

    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Pinsrd, v4, v5, arg2, &OperandSize::Size64);

5557

    // Rule at src/isa/x64/inst.isle line 3329.

5558

    return v7;

5559

5560

5561

// Generated as internal constructor for term xmm_vex_pinsr.

5562

pub fn constructor_xmm_vex_pinsr<C: Context>(

5563

    ctx: &mut C,

5564

    arg0: &AvxOpcode,

5565

    arg1: Xmm,

5566

    arg2: &GprMem,

5567

    arg3: u8,

5568

) -> Xmm {

5569

    let v4 = C::temp_writable_xmm(ctx);

5570

    let v5 = MInst::XmmVexPinsr {

5571

        op: arg0.clone(),

5572

        src1: arg1,

5573

        src2: arg2.clone(),

5574

        dst: v4,

5575

        imm: arg3,

5576

};

5577

    let v6 = C::emit(ctx, &v5);

5578

    let v7 = C::writable_xmm_to_xmm(ctx, v4);

5579

    // Rule at src/isa/x64/inst.isle line 3341.

5580

    return v7;

5581

5582

5583

// Generated as internal constructor for term xmm_unary_rm_r_imm.

5584

pub fn constructor_xmm_unary_rm_r_imm<C: Context>(

5585

    ctx: &mut C,

5586

    arg0: &SseOpcode,

5587

    arg1: &XmmMemAligned,

5588

    arg2: u8,

5589

) -> Xmm {

5590

    let v3 = C::temp_writable_xmm(ctx);

5591

    let v4 = MInst::XmmUnaryRmRImm {

5592

        op: arg0.clone(),

5593

        src: arg1.clone(),

5594

        imm: arg2,

5595

        dst: v3,

5596

};

5597

    let v5 = C::emit(ctx, &v4);

5598

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

5599

    // Rule at src/isa/x64/inst.isle line 3348.

5600

    return v6;

5601

5602

5603

// Generated as internal constructor for term x64_roundss.

5604

pub fn constructor_x64_roundss<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: &RoundImm) -> Xmm {

5605

    let v6 = C::use_avx_simd(ctx);

5606

    if v6 == true {

5607

        let v8 = C::encode_round_imm(ctx, arg1);

5608

        let v9 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vroundss, arg0, v8);

5609

        // Rule at src/isa/x64/inst.isle line 3357.

5610

        return v9;

5611

5612

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

5613

    let v4 = C::encode_round_imm(ctx, arg1);

5614

    let v5 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Roundss, v3, v4);

5615

    // Rule at src/isa/x64/inst.isle line 3355.

5616

    return v5;

5617

5618

5619

// Generated as internal constructor for term x64_roundsd.

5620

pub fn constructor_x64_roundsd<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: &RoundImm) -> Xmm {

5621

    let v6 = C::use_avx_simd(ctx);

5622

    if v6 == true {

5623

        let v8 = C::encode_round_imm(ctx, arg1);

5624

        let v9 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vroundsd, arg0, v8);

5625

        // Rule at src/isa/x64/inst.isle line 3365.

5626

        return v9;

5627

5628

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

5629

    let v4 = C::encode_round_imm(ctx, arg1);

5630

    let v5 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Roundsd, v3, v4);

5631

    // Rule at src/isa/x64/inst.isle line 3363.

5632

    return v5;

5633

5634

5635

// Generated as internal constructor for term x64_roundps.

5636

pub fn constructor_x64_roundps<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: &RoundImm) -> Xmm {

5637

    let v6 = C::use_avx_simd(ctx);

5638

    if v6 == true {

5639

        let v8 = C::encode_round_imm(ctx, arg1);

5640

        let v9 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vroundps, arg0, v8);

5641

        // Rule at src/isa/x64/inst.isle line 3373.

5642

        return v9;

5643

5644

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

5645

    let v4 = C::encode_round_imm(ctx, arg1);

5646

    let v5 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Roundps, v3, v4);

5647

    // Rule at src/isa/x64/inst.isle line 3371.

5648

    return v5;

5649

5650

5651

// Generated as internal constructor for term x64_roundpd.

5652

pub fn constructor_x64_roundpd<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: &RoundImm) -> Xmm {

5653

    let v6 = C::use_avx_simd(ctx);

5654

    if v6 == true {

5655

        let v8 = C::encode_round_imm(ctx, arg1);

5656

        let v9 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vroundpd, arg0, v8);

5657

        // Rule at src/isa/x64/inst.isle line 3381.

5658

        return v9;

5659

5660

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

5661

    let v4 = C::encode_round_imm(ctx, arg1);

5662

    let v5 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Roundpd, v3, v4);

5663

    // Rule at src/isa/x64/inst.isle line 3379.

5664

    return v5;

5665

5666

5667

// Generated as internal constructor for term x64_pmaddwd.

5668

pub fn constructor_x64_pmaddwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5669

    let v5 = C::use_avx_simd(ctx);

5670

    if v5 == true {

5671

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5672

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaddwd, arg0, v7);

5673

        // Rule at src/isa/x64/inst.isle line 3389.

5674

        return v8;

5675

5676

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5677

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaddwd, arg0, v3);

5678

    // Rule at src/isa/x64/inst.isle line 3387.

5679

    return v4;

5680

5681

5682

// Generated as internal constructor for term x64_pmaddubsw.

5683

pub fn constructor_x64_pmaddubsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5684

    let v5 = C::use_avx_simd(ctx);

5685

    if v5 == true {

5686

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5687

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaddubsw, arg0, v7);

5688

        // Rule at src/isa/x64/inst.isle line 3396.

5689

        return v8;

5690

5691

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5692

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaddubsw, arg0, v3);

5693

    // Rule at src/isa/x64/inst.isle line 3394.

5694

    return v4;

5695

5696

5697

// Generated as internal constructor for term x64_insertps.

5698

pub fn constructor_x64_insertps<C: Context>(

5699

    ctx: &mut C,

5700

    arg0: Xmm,

5701

    arg1: &XmmMem,

5702

    arg2: u8,

5703

) -> Xmm {

5704

    let v8 = C::use_avx_simd(ctx);

5705

    if v8 == true {

5706

        let v10 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vinsertps, arg0, arg1, arg2);

5707

        // Rule at src/isa/x64/inst.isle line 3408.

5708

        return v10;

5709

5710

    let v4 = C::xmm_to_reg(ctx, arg0);

5711

    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);

5712

    let v7 = constructor_xmm_rm_r_imm(

5713

        ctx,

5714

        &SseOpcode::Insertps,

5715

v4,

5716

v5,

5717

        arg2,

5718

        &OperandSize::Size32,

5719

);

5720

    // Rule at src/isa/x64/inst.isle line 3402.

5721

    return v7;

5722

5723

5724

// Generated as internal constructor for term x64_pshufd.

5725

pub fn constructor_x64_pshufd<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: u8) -> Xmm {

5726

    let v5 = C::use_avx_simd(ctx);

5727

    if v5 == true {

5728

        let v7 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vpshufd, arg0, arg1);

5729

        // Rule at src/isa/x64/inst.isle line 3416.

5730

        return v7;

5731

5732

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

5733

    let v4 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Pshufd, v3, arg1);

5734

    // Rule at src/isa/x64/inst.isle line 3414.

5735

    return v4;

5736

5737

5738

// Generated as internal constructor for term x64_pshufb.

5739

pub fn constructor_x64_pshufb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5740

    let v5 = C::use_avx_simd(ctx);

5741

    if v5 == true {

5742

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5743

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpshufb, arg0, v7);

5744

        // Rule at src/isa/x64/inst.isle line 3424.

5745

        return v8;

5746

5747

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5748

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pshufb, arg0, v3);

5749

    // Rule at src/isa/x64/inst.isle line 3422.

5750

    return v4;

5751

5752

5753

// Generated as internal constructor for term x64_pshuflw.

5754

pub fn constructor_x64_pshuflw<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: u8) -> Xmm {

5755

    let v5 = C::use_avx_simd(ctx);

5756

    if v5 == true {

5757

        let v7 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vpshuflw, arg0, arg1);

5758

        // Rule at src/isa/x64/inst.isle line 3432.

5759

        return v7;

5760

5761

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

5762

    let v4 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Pshuflw, v3, arg1);

5763

    // Rule at src/isa/x64/inst.isle line 3430.

5764

    return v4;

5765

5766

5767

// Generated as internal constructor for term x64_pshufhw.

5768

pub fn constructor_x64_pshufhw<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: u8) -> Xmm {

5769

    let v5 = C::use_avx_simd(ctx);

5770

    if v5 == true {

5771

        let v7 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vpshufhw, arg0, arg1);

5772

        // Rule at src/isa/x64/inst.isle line 3440.

5773

        return v7;

5774

5775

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

5776

    let v4 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Pshufhw, v3, arg1);

5777

    // Rule at src/isa/x64/inst.isle line 3438.

5778

    return v4;

5779

5780

5781

// Generated as internal constructor for term x64_shufps.

5782

pub fn constructor_x64_shufps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> Xmm {

5783

    let v8 = C::use_avx_simd(ctx);

5784

    if v8 == true {

5785

        let v10 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vshufps, arg0, arg1, arg2);

5786

        // Rule at src/isa/x64/inst.isle line 3452.

5787

        return v10;

5788

5789

    let v4 = C::xmm_to_reg(ctx, arg0);

5790

    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);

5791

    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Shufps, v4, v5, arg2, &OperandSize::Size32);

5792

    // Rule at src/isa/x64/inst.isle line 3446.

5793

    return v7;

5794

5795

5796

// Generated as internal constructor for term xmm_unary_rm_r.

5797

pub fn constructor_xmm_unary_rm_r<C: Context>(

5798

    ctx: &mut C,

5799

    arg0: &SseOpcode,

5800

    arg1: &XmmMemAligned,

5801

) -> Xmm {

5802

    let v2 = C::temp_writable_xmm(ctx);

5803

    let v3 = MInst::XmmUnaryRmR {

5804

        op: arg0.clone(),

5805

        src: arg1.clone(),

5806

        dst: v2,

5807

};

5808

    let v4 = C::emit(ctx, &v3);

5809

    let v5 = C::writable_xmm_to_xmm(ctx, v2);

5810

    // Rule at src/isa/x64/inst.isle line 3458.

5811

    return v5;

5812

5813

5814

// Generated as internal constructor for term xmm_unary_rm_r_unaligned.

5815

pub fn constructor_xmm_unary_rm_r_unaligned<C: Context>(

5816

    ctx: &mut C,

5817

    arg0: &SseOpcode,

5818

    arg1: &XmmMem,

5819

) -> Xmm {

5820

    let v2 = C::temp_writable_xmm(ctx);

5821

    let v3 = MInst::XmmUnaryRmRUnaligned {

5822

        op: arg0.clone(),

5823

        src: arg1.clone(),

5824

        dst: v2,

5825

};

5826

    let v4 = C::emit(ctx, &v3);

5827

    let v5 = C::writable_xmm_to_xmm(ctx, v2);

5828

    // Rule at src/isa/x64/inst.isle line 3465.

5829

    return v5;

5830

5831

5832

// Generated as internal constructor for term x64_pabsb.

5833

pub fn constructor_x64_pabsb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

5834

    let v4 = C::use_avx_simd(ctx);

5835

    if v4 == true {

5836

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpabsb, arg0);

5837

        // Rule at src/isa/x64/inst.isle line 3474.

5838

        return v6;

5839

5840

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

5841

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Pabsb, v2);

5842

    // Rule at src/isa/x64/inst.isle line 3472.

5843

    return v3;

5844

5845

5846

// Generated as internal constructor for term x64_pabsw.

5847

pub fn constructor_x64_pabsw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

5848

    let v4 = C::use_avx_simd(ctx);

5849

    if v4 == true {

5850

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpabsw, arg0);

5851

        // Rule at src/isa/x64/inst.isle line 3482.

5852

        return v6;

5853

5854

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

5855

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Pabsw, v2);

5856

    // Rule at src/isa/x64/inst.isle line 3480.

5857

    return v3;

5858

5859

5860

// Generated as internal constructor for term x64_pabsd.

5861

pub fn constructor_x64_pabsd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

5862

    let v4 = C::use_avx_simd(ctx);

5863

    if v4 == true {

5864

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpabsd, arg0);

5865

        // Rule at src/isa/x64/inst.isle line 3490.

5866

        return v6;

5867

5868

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

5869

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Pabsd, v2);

5870

    // Rule at src/isa/x64/inst.isle line 3488.

5871

    return v3;

5872

5873

5874

// Generated as internal constructor for term xmm_unary_rm_r_evex.

5875

pub fn constructor_xmm_unary_rm_r_evex<C: Context>(

5876

    ctx: &mut C,

5877

    arg0: &Avx512Opcode,

5878

    arg1: &XmmMem,

5879

) -> Xmm {

5880

    let v2 = C::temp_writable_xmm(ctx);

5881

    let v3 = MInst::XmmUnaryRmREvex {

5882

        op: arg0.clone(),

5883

        src: arg1.clone(),

5884

        dst: v2,

5885

};

5886

    let v4 = C::emit(ctx, &v3);

5887

    let v5 = C::writable_xmm_to_xmm(ctx, v2);

5888

    // Rule at src/isa/x64/inst.isle line 3496.

5889

    return v5;

5890

5891

5892

// Generated as internal constructor for term x64_vcvtudq2ps.

5893

pub fn constructor_x64_vcvtudq2ps<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

5894

    let v2 = constructor_xmm_unary_rm_r_evex(ctx, &Avx512Opcode::Vcvtudq2ps, arg0);

5895

    // Rule at src/isa/x64/inst.isle line 3503.

5896

    return v2;

5897

5898

5899

// Generated as internal constructor for term x64_vpabsq.

5900

pub fn constructor_x64_vpabsq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

5901

    let v2 = constructor_xmm_unary_rm_r_evex(ctx, &Avx512Opcode::Vpabsq, arg0);

5902

    // Rule at src/isa/x64/inst.isle line 3508.

5903

    return v2;

5904

5905

5906

// Generated as internal constructor for term x64_vpopcntb.

5907

pub fn constructor_x64_vpopcntb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

5908

    let v2 = constructor_xmm_unary_rm_r_evex(ctx, &Avx512Opcode::Vpopcntb, arg0);

5909

    // Rule at src/isa/x64/inst.isle line 3513.

5910

    return v2;

5911

5912

5913

// Generated as internal constructor for term xmm_rm_r_evex.

5914

pub fn constructor_xmm_rm_r_evex<C: Context>(

5915

    ctx: &mut C,

5916

    arg0: &Avx512Opcode,

5917

    arg1: &XmmMem,

5918

    arg2: Xmm,

5919

) -> Xmm {

5920

    let v3 = C::temp_writable_xmm(ctx);

5921

    let v4 = MInst::XmmRmREvex {

5922

        op: arg0.clone(),

5923

        src1: arg1.clone(),

5924

        src2: arg2,

5925

        dst: v3,

5926

};

5927

    let v5 = C::emit(ctx, &v4);

5928

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

5929

    // Rule at src/isa/x64/inst.isle line 3518.

5930

    return v6;

5931

5932

5933

// Generated as internal constructor for term x64_vpmullq.

5934

pub fn constructor_x64_vpmullq<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: Xmm) -> Xmm {

5935

    let v3 = constructor_xmm_rm_r_evex(ctx, &Avx512Opcode::Vpmullq, arg0, arg1);

5936

    // Rule at src/isa/x64/inst.isle line 3530.

5937

    return v3;

5938

5939

5940

// Generated as internal constructor for term x64_vpermi2b.

5941

pub fn constructor_x64_vpermi2b<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm, arg2: Xmm) -> Xmm {

5942

    let v3 = C::temp_writable_xmm(ctx);

5943

    let v5 = &C::xmm_to_xmm_mem(ctx, arg0);

5944

    let v6 = MInst::XmmRmREvex3 {

5945

        op: Avx512Opcode::Vpermi2b,

5946

        src1: v5.clone(),

5947

        src2: arg1,

5948

        src3: arg2,

5949

        dst: v3,

5950

};

5951

    let v7 = C::emit(ctx, &v6);

5952

    let v8 = C::writable_xmm_to_xmm(ctx, v3);

5953

    // Rule at src/isa/x64/inst.isle line 3539.

5954

    return v8;

5955

5956

5957

// Generated as internal constructor for term mul_hi.

5958

pub fn constructor_mul_hi<C: Context>(

5959

    ctx: &mut C,

5960

    arg0: Type,

5961

    arg1: bool,

5962

    arg2: Gpr,

5963

    arg3: &GprMem,

5964

) -> ValueRegs {

5965

    let v4 = C::temp_writable_gpr(ctx);

5966

    let v5 = C::temp_writable_gpr(ctx);

5967

    let v6 = &C::raw_operand_size_of_type(ctx, arg0);

5968

    let v7 = MInst::MulHi {

5969

        size: v6.clone(),

5970

        signed: arg1,

5971

        src1: arg2,

5972

        src2: arg3.clone(),

5973

        dst_lo: v4,

5974

        dst_hi: v5,

5975

};

5976

    let v8 = C::emit(ctx, &v7);

5977

    let v9 = C::writable_gpr_to_gpr(ctx, v4);

5978

    let v10 = C::writable_gpr_to_gpr(ctx, v5);

5979

    let v11 = constructor_value_gprs(ctx, v9, v10);

5980

    // Rule at src/isa/x64/inst.isle line 3552.

5981

    return v11;

5982

5983

5984

// Generated as internal constructor for term mulhi_u.

5985

pub fn constructor_mulhi_u<C: Context>(

5986

    ctx: &mut C,

5987

    arg0: Type,

5988

    arg1: Gpr,

5989

    arg2: &GprMem,

5990

) -> ValueRegs {

5991

    let v4 = constructor_mul_hi(ctx, arg0, false, arg1, arg2);

5992

    // Rule at src/isa/x64/inst.isle line 3567.

5993

    return v4;

5994

5995

5996

// Generated as internal constructor for term xmm_rmi_xmm.

5997

pub fn constructor_xmm_rmi_xmm<C: Context>(

5998

    ctx: &mut C,

5999

    arg0: &SseOpcode,

6000

    arg1: Xmm,

6001

    arg2: &XmmMemAlignedImm,

6002

) -> Xmm {

6003

    let v3 = C::temp_writable_xmm(ctx);

6004

    let v4 = MInst::XmmRmiReg {

6005

        opcode: arg0.clone(),

6006

        src1: arg1,

6007

        src2: arg2.clone(),

6008

        dst: v3,

6009

};

6010

    let v5 = C::emit(ctx, &v4);

6011

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

6012

    // Rule at src/isa/x64/inst.isle line 3572.

6013

    return v6;

6014

6015

6016

// Generated as internal constructor for term x64_psllw.

6017

pub fn constructor_x64_psllw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

6018

    let v5 = C::use_avx_simd(ctx);

6019

    if v5 == true {

6020

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsllw, arg0, arg1);

6021

        // Rule at src/isa/x64/inst.isle line 3584.

6022

        return v7;

6023

6024

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

6025

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psllw, arg0, v3);

6026

    // Rule at src/isa/x64/inst.isle line 3582.

6027

    return v4;

6028

6029

6030

// Generated as internal constructor for term x64_pslld.

6031

pub fn constructor_x64_pslld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

6032

    let v5 = C::use_avx_simd(ctx);

6033

    if v5 == true {

6034

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpslld, arg0, arg1);

6035

        // Rule at src/isa/x64/inst.isle line 3592.

6036

        return v7;

6037

6038

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

6039

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Pslld, arg0, v3);

6040

    // Rule at src/isa/x64/inst.isle line 3590.

6041

    return v4;

6042

6043

6044

// Generated as internal constructor for term x64_psllq.

6045

pub fn constructor_x64_psllq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

6046

    let v5 = C::use_avx_simd(ctx);

6047

    if v5 == true {

6048

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsllq, arg0, arg1);

6049

        // Rule at src/isa/x64/inst.isle line 3600.

6050

        return v7;

6051

6052

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

6053

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psllq, arg0, v3);

6054

    // Rule at src/isa/x64/inst.isle line 3598.

6055

    return v4;

6056

6057

6058

// Generated as internal constructor for term x64_psrlw.

6059

pub fn constructor_x64_psrlw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

6060

    let v5 = C::use_avx_simd(ctx);

6061

    if v5 == true {

6062

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsrlw, arg0, arg1);

6063

        // Rule at src/isa/x64/inst.isle line 3608.

6064

        return v7;

6065

6066

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

6067

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psrlw, arg0, v3);

6068

    // Rule at src/isa/x64/inst.isle line 3606.

6069

    return v4;

6070

6071

6072

// Generated as internal constructor for term x64_psrld.

6073

pub fn constructor_x64_psrld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

6074

    let v5 = C::use_avx_simd(ctx);

6075

    if v5 == true {

6076

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsrld, arg0, arg1);

6077

        // Rule at src/isa/x64/inst.isle line 3616.

6078

        return v7;

6079

6080

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

6081

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psrld, arg0, v3);

6082

    // Rule at src/isa/x64/inst.isle line 3614.

6083

    return v4;

6084

6085

6086

// Generated as internal constructor for term x64_psrlq.

6087

pub fn constructor_x64_psrlq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

6088

    let v5 = C::use_avx_simd(ctx);

6089

    if v5 == true {

6090

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsrlq, arg0, arg1);

6091

        // Rule at src/isa/x64/inst.isle line 3624.

6092

        return v7;

6093

6094

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

6095

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psrlq, arg0, v3);

6096

    // Rule at src/isa/x64/inst.isle line 3622.

6097

    return v4;

6098

6099

6100

// Generated as internal constructor for term x64_psraw.

6101

pub fn constructor_x64_psraw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

6102

    let v5 = C::use_avx_simd(ctx);

6103

    if v5 == true {

6104

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsraw, arg0, arg1);

6105

        // Rule at src/isa/x64/inst.isle line 3632.

6106

        return v7;

6107

6108

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

6109

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psraw, arg0, v3);

6110

    // Rule at src/isa/x64/inst.isle line 3630.

6111

    return v4;

6112

6113

6114

// Generated as internal constructor for term x64_psrad.

6115

pub fn constructor_x64_psrad<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

6116

    let v5 = C::use_avx_simd(ctx);

6117

    if v5 == true {

6118

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsrad, arg0, arg1);

6119

        // Rule at src/isa/x64/inst.isle line 3640.

6120

        return v7;

6121

6122

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

6123

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psrad, arg0, v3);

6124

    // Rule at src/isa/x64/inst.isle line 3638.

6125

    return v4;

6126

6127

6128

// Generated as internal constructor for term x64_pextrb.

6129

pub fn constructor_x64_pextrb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: u8) -> Gpr {

6130

    let v4 = C::use_avx_simd(ctx);

6131

    if v4 == true {

6132

        let v6 = constructor_xmm_to_gpr_imm_vex(ctx, &AvxOpcode::Vpextrb, arg0, arg1);

6133

        // Rule at src/isa/x64/inst.isle line 3648.

6134

        return v6;

6135

6136

    let v3 = constructor_xmm_to_gpr_imm(ctx, &SseOpcode::Pextrb, arg0, arg1);

6137

    // Rule at src/isa/x64/inst.isle line 3646.

6138

    return v3;

6139

6140

6141

// Generated as internal constructor for term x64_pextrb_store.

6142

pub fn constructor_x64_pextrb_store<C: Context>(

6143

    ctx: &mut C,

6144

    arg0: &SyntheticAmode,

6145

    arg1: Xmm,

6146

    arg2: u8,

6147

) -> SideEffectNoResult {

6148

    let v5 = C::use_avx_simd(ctx);

6149

    if v5 == true {

6150

        let v7 = &constructor_xmm_movrm_imm_vex(ctx, &AvxOpcode::Vpextrb, arg0, arg1, arg2);

6151

        // Rule at src/isa/x64/inst.isle line 3655.

6152

        return v7.clone();

6153

6154

    let v4 = &constructor_xmm_movrm_imm(ctx, &SseOpcode::Pextrb, arg0, arg1, arg2);

6155

    // Rule at src/isa/x64/inst.isle line 3653.

6156

    return v4.clone();

6157

6158

6159

// Generated as internal constructor for term x64_pextrw.

6160

pub fn constructor_x64_pextrw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: u8) -> Gpr {

6161

    let v4 = C::use_avx_simd(ctx);

6162

    if v4 == true {

6163

        let v6 = constructor_xmm_to_gpr_imm_vex(ctx, &AvxOpcode::Vpextrw, arg0, arg1);

6164

        // Rule at src/isa/x64/inst.isle line 3663.

6165

        return v6;

6166

6167

    let v3 = constructor_xmm_to_gpr_imm(ctx, &SseOpcode::Pextrw, arg0, arg1);

6168

    // Rule at src/isa/x64/inst.isle line 3661.

6169

    return v3;

6170

6171

6172

// Generated as internal constructor for term x64_pextrw_store.

6173

pub fn constructor_x64_pextrw_store<C: Context>(

6174

    ctx: &mut C,

6175

    arg0: &SyntheticAmode,

6176

    arg1: Xmm,

6177

    arg2: u8,

6178

) -> SideEffectNoResult {

6179

    let v5 = C::use_avx_simd(ctx);

6180

    if v5 == true {

6181

        let v7 = &constructor_xmm_movrm_imm_vex(ctx, &AvxOpcode::Vpextrw, arg0, arg1, arg2);

6182

        // Rule at src/isa/x64/inst.isle line 3670.

6183

        return v7.clone();

6184

6185

    let v4 = &constructor_xmm_movrm_imm(ctx, &SseOpcode::Pextrw, arg0, arg1, arg2);

6186

    // Rule at src/isa/x64/inst.isle line 3668.

6187

    return v4.clone();

6188

6189

6190

// Generated as internal constructor for term x64_pextrd.

6191

pub fn constructor_x64_pextrd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: u8) -> Gpr {

6192

    let v4 = C::use_avx_simd(ctx);

6193

    if v4 == true {

6194

        let v6 = constructor_xmm_to_gpr_imm_vex(ctx, &AvxOpcode::Vpextrd, arg0, arg1);

6195

        // Rule at src/isa/x64/inst.isle line 3678.

6196

        return v6;

6197

6198

    let v3 = constructor_xmm_to_gpr_imm(ctx, &SseOpcode::Pextrd, arg0, arg1);

6199

    // Rule at src/isa/x64/inst.isle line 3676.

6200

    return v3;

6201

6202

6203

// Generated as internal constructor for term x64_pextrd_store.

6204

pub fn constructor_x64_pextrd_store<C: Context>(

6205

    ctx: &mut C,

6206

    arg0: &SyntheticAmode,

6207

    arg1: Xmm,

6208

    arg2: u8,

6209

) -> SideEffectNoResult {

6210

    let v5 = C::use_avx_simd(ctx);

6211

    if v5 == true {

6212

        let v7 = &constructor_xmm_movrm_imm_vex(ctx, &AvxOpcode::Vpextrd, arg0, arg1, arg2);

6213

        // Rule at src/isa/x64/inst.isle line 3685.

6214

        return v7.clone();

6215

6216

    let v4 = &constructor_xmm_movrm_imm(ctx, &SseOpcode::Pextrd, arg0, arg1, arg2);

6217

    // Rule at src/isa/x64/inst.isle line 3683.

6218

    return v4.clone();

6219

6220

6221

// Generated as internal constructor for term x64_pextrq.

6222

pub fn constructor_x64_pextrq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: u8) -> Gpr {

6223

    let v4 = C::use_avx_simd(ctx);

6224

    if v4 == true {

6225

        let v6 = constructor_xmm_to_gpr_imm_vex(ctx, &AvxOpcode::Vpextrq, arg0, arg1);

6226

        // Rule at src/isa/x64/inst.isle line 3693.

6227

        return v6;

6228

6229

    let v3 = constructor_xmm_to_gpr_imm(ctx, &SseOpcode::Pextrq, arg0, arg1);

6230

    // Rule at src/isa/x64/inst.isle line 3691.

6231

    return v3;

6232

6233

6234

// Generated as internal constructor for term x64_pextrq_store.

6235

pub fn constructor_x64_pextrq_store<C: Context>(

6236

    ctx: &mut C,

6237

    arg0: &SyntheticAmode,

6238

    arg1: Xmm,

6239

    arg2: u8,

6240

) -> SideEffectNoResult {

6241

    let v5 = C::use_avx_simd(ctx);

6242

    if v5 == true {

6243

        let v7 = &constructor_xmm_movrm_imm_vex(ctx, &AvxOpcode::Vpextrq, arg0, arg1, arg2);

6244

        // Rule at src/isa/x64/inst.isle line 3700.

6245

        return v7.clone();

6246

6247

    let v4 = &constructor_xmm_movrm_imm(ctx, &SseOpcode::Pextrq, arg0, arg1, arg2);

6248

    // Rule at src/isa/x64/inst.isle line 3698.

6249

    return v4.clone();

6250

6251

6252

// Generated as internal constructor for term xmm_to_gpr.

6253

pub fn constructor_xmm_to_gpr<C: Context>(

6254

    ctx: &mut C,

6255

    arg0: &SseOpcode,

6256

    arg1: Xmm,

6257

    arg2: &OperandSize,

6258

) -> Gpr {

6259

    let v3 = C::temp_writable_gpr(ctx);

6260

    let v4 = MInst::XmmToGpr {

6261

        op: arg0.clone(),

6262

        src: arg1,

6263

        dst: v3,

6264

        dst_size: arg2.clone(),

6265

};

6266

    let v5 = C::emit(ctx, &v4);

6267

    let v6 = C::writable_gpr_to_gpr(ctx, v3);

6268

    // Rule at src/isa/x64/inst.isle line 3706.

6269

    return v6;

6270

6271

6272

// Generated as internal constructor for term xmm_to_gpr_imm.

6273

pub fn constructor_xmm_to_gpr_imm<C: Context>(

6274

    ctx: &mut C,

6275

    arg0: &SseOpcode,

6276

    arg1: Xmm,

6277

    arg2: u8,

6278

) -> Gpr {

6279

    let v3 = C::temp_writable_gpr(ctx);

6280

    let v4 = MInst::XmmToGprImm {

6281

        op: arg0.clone(),

6282

        src: arg1,

6283

        dst: v3,

6284

        imm: arg2,

6285

};

6286

    let v5 = C::emit(ctx, &v4);

6287

    let v6 = C::writable_gpr_to_gpr(ctx, v3);

6288

    // Rule at src/isa/x64/inst.isle line 3713.

6289

    return v6;

6290

6291

6292

// Generated as internal constructor for term xmm_to_gpr_imm_vex.

6293

pub fn constructor_xmm_to_gpr_imm_vex<C: Context>(

6294

    ctx: &mut C,

6295

    arg0: &AvxOpcode,

6296

    arg1: Xmm,

6297

    arg2: u8,

6298

) -> Gpr {

6299

    let v3 = C::temp_writable_gpr(ctx);

6300

    let v4 = MInst::XmmToGprImmVex {

6301

        op: arg0.clone(),

6302

        src: arg1,

6303

        dst: v3,

6304

        imm: arg2,

6305

};

6306

    let v5 = C::emit(ctx, &v4);

6307

    let v6 = C::writable_gpr_to_gpr(ctx, v3);

6308

    // Rule at src/isa/x64/inst.isle line 3720.

6309

    return v6;

6310

6311

6312

// Generated as internal constructor for term xmm_to_gpr_vex.

6313

pub fn constructor_xmm_to_gpr_vex<C: Context>(

6314

    ctx: &mut C,

6315

    arg0: &AvxOpcode,

6316

    arg1: Xmm,

6317

    arg2: &OperandSize,

6318

) -> Gpr {

6319

    let v3 = C::temp_writable_gpr(ctx);

6320

    let v4 = MInst::XmmToGprVex {

6321

        op: arg0.clone(),

6322

        src: arg1,

6323

        dst: v3,

6324

        dst_size: arg2.clone(),

6325

};

6326

    let v5 = C::emit(ctx, &v4);

6327

    let v6 = C::writable_gpr_to_gpr(ctx, v3);

6328

    // Rule at src/isa/x64/inst.isle line 3727.

6329

    return v6;

6330

6331

6332

// Generated as internal constructor for term gpr_to_xmm_vex.

6333

pub fn constructor_gpr_to_xmm_vex<C: Context>(

6334

    ctx: &mut C,

6335

    arg0: &AvxOpcode,

6336

    arg1: &GprMem,

6337

    arg2: &OperandSize,

6338

) -> Xmm {

6339

    let v3 = C::temp_writable_xmm(ctx);

6340

    let v4 = MInst::GprToXmmVex {

6341

        op: arg0.clone(),

6342

        src: arg1.clone(),

6343

        dst: v3,

6344

        src_size: arg2.clone(),

6345

};

6346

    let v5 = C::emit(ctx, &v4);

6347

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

6348

    // Rule at src/isa/x64/inst.isle line 3734.

6349

    return v6;

6350

6351

6352

// Generated as internal constructor for term x64_pmovmskb.

6353

pub fn constructor_x64_pmovmskb<C: Context>(ctx: &mut C, arg0: &OperandSize, arg1: Xmm) -> Gpr {

6354

    let v4 = C::use_avx_simd(ctx);

6355

    if v4 == true {

6356

        let v6 = constructor_xmm_to_gpr_vex(ctx, &AvxOpcode::Vpmovmskb, arg1, arg0);

6357

        // Rule at src/isa/x64/inst.isle line 3744.

6358

        return v6;

6359

6360

    let v3 = constructor_xmm_to_gpr(ctx, &SseOpcode::Pmovmskb, arg1, arg0);

6361

    // Rule at src/isa/x64/inst.isle line 3742.

6362

    return v3;

6363

6364

6365

// Generated as internal constructor for term x64_movmskps.

6366

pub fn constructor_x64_movmskps<C: Context>(ctx: &mut C, arg0: &OperandSize, arg1: Xmm) -> Gpr {

6367

    let v4 = C::use_avx_simd(ctx);

6368

    if v4 == true {

6369

        let v6 = constructor_xmm_to_gpr_vex(ctx, &AvxOpcode::Vmovmskps, arg1, arg0);

6370

        // Rule at src/isa/x64/inst.isle line 3752.

6371

        return v6;

6372

6373

    let v3 = constructor_xmm_to_gpr(ctx, &SseOpcode::Movmskps, arg1, arg0);

6374

    // Rule at src/isa/x64/inst.isle line 3750.

6375

    return v3;

6376

6377

6378

// Generated as internal constructor for term x64_movmskpd.

6379

pub fn constructor_x64_movmskpd<C: Context>(ctx: &mut C, arg0: &OperandSize, arg1: Xmm) -> Gpr {

6380

    let v4 = C::use_avx_simd(ctx);

6381

    if v4 == true {

6382

        let v6 = constructor_xmm_to_gpr_vex(ctx, &AvxOpcode::Vmovmskpd, arg1, arg0);

6383

        // Rule at src/isa/x64/inst.isle line 3760.

6384

        return v6;

6385

6386

    let v3 = constructor_xmm_to_gpr(ctx, &SseOpcode::Movmskpd, arg1, arg0);

6387

    // Rule at src/isa/x64/inst.isle line 3758.

6388

    return v3;

6389

6390

6391

// Generated as internal constructor for term gpr_to_xmm.

6392

pub fn constructor_gpr_to_xmm<C: Context>(

6393

    ctx: &mut C,

6394

    arg0: &SseOpcode,

6395

    arg1: &GprMem,

6396

    arg2: &OperandSize,

6397

) -> Xmm {

6398

    let v3 = C::temp_writable_xmm(ctx);

6399

    let v4 = MInst::GprToXmm {

6400

        op: arg0.clone(),

6401

        src: arg1.clone(),

6402

        dst: v3,

6403

        src_size: arg2.clone(),

6404

};

6405

    let v5 = C::emit(ctx, &v4);

6406

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

6407

    // Rule at src/isa/x64/inst.isle line 3766.

6408

    return v6;

6409

6410

6411

// Generated as internal constructor for term x64_not.

6412

pub fn constructor_x64_not<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

6413

    let v2 = C::temp_writable_gpr(ctx);

6414

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

6415

    let v4 = MInst::Not {

6416

        size: v3.clone(),

6417

        src: arg1,

6418

        dst: v2,

6419

};

6420

    let v5 = C::emit(ctx, &v4);

6421

    let v6 = C::writable_gpr_to_gpr(ctx, v2);

6422

    // Rule at src/isa/x64/inst.isle line 3773.

6423

    return v6;

6424

6425

6426

// Generated as internal constructor for term x64_neg.

6427

pub fn constructor_x64_neg<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

6428

    let v2 = C::temp_writable_gpr(ctx);

6429

    let v3 = &C::raw_operand_size_of_type(ctx, arg0);

6430

    let v4 = MInst::Neg {

6431

        size: v3.clone(),

6432

        src: arg1,

6433

        dst: v2,

6434

};

6435

    let v5 = C::emit(ctx, &v4);

6436

    let v6 = C::writable_gpr_to_gpr(ctx, v2);

6437

    // Rule at src/isa/x64/inst.isle line 3781.

6438

    return v6;

6439

6440

6441

// Generated as internal constructor for term x64_neg_paired.

6442

pub fn constructor_x64_neg_paired<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> ProducesFlags {

6443

    let v2 = C::temp_writable_gpr(ctx);

6444

    let v3 = &C::raw_operand_size_of_type(ctx, arg0);

6445

    let v5 = constructor_writable_gpr_to_r_reg(ctx, v2);

6446

    let v4 = MInst::Neg {

6447

        size: v3.clone(),

6448

        src: arg1,

6449

        dst: v2,

6450

};

6451

    let v6 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {

6452

        inst: v4,

6453

        result: v5,

6454

};

6455

    // Rule at src/isa/x64/inst.isle line 3789.

6456

    return v6;

6457

6458

6459

// Generated as internal constructor for term x64_lea.

6460

pub fn constructor_x64_lea<C: Context>(ctx: &mut C, arg0: Type, arg1: &SyntheticAmode) -> Gpr {

6461

    let v2 = C::temp_writable_gpr(ctx);

6462

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

6463

    let v4 = MInst::LoadEffectiveAddress {

6464

        addr: arg1.clone(),

6465

        dst: v2,

6466

        size: v3.clone(),

6467

};

6468

    let v5 = C::emit(ctx, &v4);

6469

    let v6 = C::writable_gpr_to_gpr(ctx, v2);

6470

    // Rule at src/isa/x64/inst.isle line 3796.

6471

    return v6;

6472

6473

6474

// Generated as internal constructor for term x64_ud2.

6475

pub fn constructor_x64_ud2<C: Context>(ctx: &mut C, arg0: &TrapCode) -> SideEffectNoResult {

6476

    let v1 = MInst::Ud2 {

6477

        trap_code: arg0.clone(),

6478

};

6479

    let v2 = SideEffectNoResult::Inst { inst: v1 };

6480

    // Rule at src/isa/x64/inst.isle line 3803.

6481

    return v2;

6482

6483

6484

// Generated as internal constructor for term x64_hlt.

6485

pub fn constructor_x64_hlt<C: Context>(ctx: &mut C) -> SideEffectNoResult {

6486

    let v1 = SideEffectNoResult::Inst { inst: MInst::Hlt };

6487

    // Rule at src/isa/x64/inst.isle line 3808.

6488

    return v1;

6489

6490

6491

// Generated as internal constructor for term x64_lzcnt.

6492

pub fn constructor_x64_lzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

6493

    let v2 = C::temp_writable_gpr(ctx);

6494

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

6495

    let v5 = &C::gpr_to_gpr_mem(ctx, arg1);

6496

    let v6 = MInst::UnaryRmR {

6497

        size: v3.clone(),

6498

        op: UnaryRmROpcode::Lzcnt,

6499

        src: v5.clone(),

6500

        dst: v2,

6501

};

6502

    let v7 = C::emit(ctx, &v6);

6503

    let v8 = C::writable_gpr_to_gpr(ctx, v2);

6504

    // Rule at src/isa/x64/inst.isle line 3813.

6505

    return v8;

6506

6507

6508

// Generated as internal constructor for term x64_tzcnt.

6509

pub fn constructor_x64_tzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

6510

    let v2 = C::temp_writable_gpr(ctx);

6511

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

6512

    let v5 = &C::gpr_to_gpr_mem(ctx, arg1);

6513

    let v6 = MInst::UnaryRmR {

6514

        size: v3.clone(),

6515

        op: UnaryRmROpcode::Tzcnt,

6516

        src: v5.clone(),

6517

        dst: v2,

6518

};

6519

    let v7 = C::emit(ctx, &v6);

6520

    let v8 = C::writable_gpr_to_gpr(ctx, v2);

6521

    // Rule at src/isa/x64/inst.isle line 3821.

6522

    return v8;

6523

6524

6525

// Generated as internal constructor for term x64_bsr.

6526

pub fn constructor_x64_bsr<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> ProducesFlags {

6527

    let v2 = C::temp_writable_gpr(ctx);

6528

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

6529

    let v5 = &C::gpr_to_gpr_mem(ctx, arg1);

6530

    let v7 = constructor_writable_gpr_to_r_reg(ctx, v2);

6531

    let v6 = MInst::UnaryRmR {

6532

        size: v3.clone(),

6533

        op: UnaryRmROpcode::Bsr,

6534

        src: v5.clone(),

6535

        dst: v2,

6536

};

6537

    let v8 = ProducesFlags::ProducesFlagsReturnsReg {

6538

        inst: v6,

6539

        result: v7,

6540

};

6541

    // Rule at src/isa/x64/inst.isle line 3829.

6542

    return v8;

6543

6544

6545

// Generated as internal constructor for term bsr_or_else.

6546

pub fn constructor_bsr_or_else<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: Gpr) -> Gpr {

6547

    let v3 = &constructor_x64_bsr(ctx, arg0, arg1);

6548

    let v4 = constructor_produces_flags_get_reg(ctx, v3);

6549

    let v5 = C::gpr_new(ctx, v4);

6550

    let v7 = &C::gpr_to_gpr_mem(ctx, arg2);

6551

    let v8 = &constructor_cmove(ctx, arg0, &CC::Z, v7, v5);

6552

    let v9 = &constructor_produces_flags_ignore(ctx, v3);

6553

    let v10 = constructor_with_flags_reg(ctx, v9, v8);

6554

    let v11 = C::gpr_new(ctx, v10);

6555

    // Rule at src/isa/x64/inst.isle line 3838.

6556

    return v11;

6557

6558

6559

// Generated as internal constructor for term x64_bsf.

6560

pub fn constructor_x64_bsf<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> ProducesFlags {

6561

    let v2 = C::temp_writable_gpr(ctx);

6562

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

6563

    let v5 = &C::gpr_to_gpr_mem(ctx, arg1);

6564

    let v7 = constructor_writable_gpr_to_r_reg(ctx, v2);

6565

    let v6 = MInst::UnaryRmR {

6566

        size: v3.clone(),

6567

        op: UnaryRmROpcode::Bsf,

6568

        src: v5.clone(),

6569

        dst: v2,

6570

};

6571

    let v8 = ProducesFlags::ProducesFlagsReturnsReg {

6572

        inst: v6,

6573

        result: v7,

6574

};

6575

    // Rule at src/isa/x64/inst.isle line 3849.

6576

    return v8;

6577

6578

6579

// Generated as internal constructor for term bsf_or_else.

6580

pub fn constructor_bsf_or_else<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: Gpr) -> Gpr {

6581

    let v3 = &constructor_x64_bsf(ctx, arg0, arg1);

6582

    let v4 = constructor_produces_flags_get_reg(ctx, v3);

6583

    let v5 = C::gpr_new(ctx, v4);

6584

    let v7 = &C::gpr_to_gpr_mem(ctx, arg2);

6585

    let v8 = &constructor_cmove(ctx, arg0, &CC::Z, v7, v5);

6586

    let v9 = &constructor_produces_flags_ignore(ctx, v3);

6587

    let v10 = constructor_with_flags_reg(ctx, v9, v8);

6588

    let v11 = C::gpr_new(ctx, v10);

6589

    // Rule at src/isa/x64/inst.isle line 3858.

6590

    return v11;

6591

6592

6593

// Generated as internal constructor for term x64_popcnt.

6594

pub fn constructor_x64_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

6595

    let v2 = C::temp_writable_gpr(ctx);

6596

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

6597

    let v5 = &C::gpr_to_gpr_mem(ctx, arg1);

6598

    let v6 = MInst::UnaryRmR {

6599

        size: v3.clone(),

6600

        op: UnaryRmROpcode::Popcnt,

6601

        src: v5.clone(),

6602

        dst: v2,

6603

};

6604

    let v7 = C::emit(ctx, &v6);

6605

    let v8 = C::writable_gpr_to_gpr(ctx, v2);

6606

    // Rule at src/isa/x64/inst.isle line 3869.

6607

    return v8;

6608

6609

6610

// Generated as internal constructor for term xmm_min_max_seq.

6611

pub fn constructor_xmm_min_max_seq<C: Context>(

6612

    ctx: &mut C,

6613

    arg0: Type,

6614

    arg1: bool,

6615

    arg2: Xmm,

6616

    arg3: Xmm,

6617

) -> Xmm {

6618

    let v4 = C::temp_writable_xmm(ctx);

6619

    let v5 = &C::operand_size_of_type_32_64(ctx, arg0);

6620

    let v6 = MInst::XmmMinMaxSeq {

6621

        size: v5.clone(),

6622

        is_min: arg1,

6623

        lhs: arg2,

6624

        rhs: arg3,

6625

        dst: v4,

6626

};

6627

    let v7 = C::emit(ctx, &v6);

6628

    let v8 = C::writable_xmm_to_xmm(ctx, v4);

6629

    // Rule at src/isa/x64/inst.isle line 3877.

6630

    return v8;

6631

6632

6633

// Generated as internal constructor for term x64_minss.

6634

pub fn constructor_x64_minss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6635

    let v4 = C::use_avx_simd(ctx);

6636

    if v4 == true {

6637

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6638

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vminss, arg0, v6);

6639

        // Rule at src/isa/x64/inst.isle line 3887.

6640

        return v7;

6641

6642

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Minss, arg0, arg1);

6643

    // Rule at src/isa/x64/inst.isle line 3885.

6644

    return v3;

6645

6646

6647

// Generated as internal constructor for term x64_minsd.

6648

pub fn constructor_x64_minsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6649

    let v4 = C::use_avx_simd(ctx);

6650

    if v4 == true {

6651

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6652

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vminsd, arg0, v6);

6653

        // Rule at src/isa/x64/inst.isle line 3895.

6654

        return v7;

6655

6656

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Minsd, arg0, arg1);

6657

    // Rule at src/isa/x64/inst.isle line 3893.

6658

    return v3;

6659

6660

6661

// Generated as internal constructor for term x64_minps.

6662

pub fn constructor_x64_minps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6663

    let v5 = C::use_avx_simd(ctx);

6664

    if v5 == true {

6665

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6666

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vminps, arg0, v7);

6667

        // Rule at src/isa/x64/inst.isle line 3903.

6668

        return v8;

6669

6670

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6671

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Minps, arg0, v3);

6672

    // Rule at src/isa/x64/inst.isle line 3901.

6673

    return v4;

6674

6675

6676

// Generated as internal constructor for term x64_minpd.

6677

pub fn constructor_x64_minpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6678

    let v5 = C::use_avx_simd(ctx);

6679

    if v5 == true {

6680

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6681

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vminpd, arg0, v7);

6682

        // Rule at src/isa/x64/inst.isle line 3911.

6683

        return v8;

6684

6685

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6686

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Minpd, arg0, v3);

6687

    // Rule at src/isa/x64/inst.isle line 3909.

6688

    return v4;

6689

6690

6691

// Generated as internal constructor for term x64_maxss.

6692

pub fn constructor_x64_maxss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6693

    let v4 = C::use_avx_simd(ctx);

6694

    if v4 == true {

6695

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6696

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmaxss, arg0, v6);

6697

        // Rule at src/isa/x64/inst.isle line 3919.

6698

        return v7;

6699

6700

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Maxss, arg0, arg1);

6701

    // Rule at src/isa/x64/inst.isle line 3917.

6702

    return v3;

6703

6704

6705

// Generated as internal constructor for term x64_maxsd.

6706

pub fn constructor_x64_maxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6707

    let v4 = C::use_avx_simd(ctx);

6708

    if v4 == true {

6709

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6710

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmaxsd, arg0, v6);

6711

        // Rule at src/isa/x64/inst.isle line 3927.

6712

        return v7;

6713

6714

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Maxsd, arg0, arg1);

6715

    // Rule at src/isa/x64/inst.isle line 3925.

6716

    return v3;

6717

6718

6719

// Generated as internal constructor for term x64_maxps.

6720

pub fn constructor_x64_maxps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6721

    let v5 = C::use_avx_simd(ctx);

6722

    if v5 == true {

6723

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6724

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmaxps, arg0, v7);

6725

        // Rule at src/isa/x64/inst.isle line 3935.

6726

        return v8;

6727

6728

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6729

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Maxps, arg0, v3);

6730

    // Rule at src/isa/x64/inst.isle line 3933.

6731

    return v4;

6732

6733

6734

// Generated as internal constructor for term x64_maxpd.

6735

pub fn constructor_x64_maxpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6736

    let v5 = C::use_avx_simd(ctx);

6737

    if v5 == true {

6738

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6739

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmaxpd, arg0, v7);

6740

        // Rule at src/isa/x64/inst.isle line 3943.

6741

        return v8;

6742

6743

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6744

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Maxpd, arg0, v3);

6745

    // Rule at src/isa/x64/inst.isle line 3941.

6746

    return v4;

6747

6748

6749

// Generated as internal constructor for term xmm_rmir_vex.

6750

pub fn constructor_xmm_rmir_vex<C: Context>(

6751

    ctx: &mut C,

6752

    arg0: &AvxOpcode,

6753

    arg1: Xmm,

6754

    arg2: &XmmMemImm,

6755

) -> Xmm {

6756

    let v3 = C::temp_writable_xmm(ctx);

6757

    let v4 = MInst::XmmRmiRVex {

6758

        op: arg0.clone(),

6759

        src1: arg1,

6760

        src2: arg2.clone(),

6761

        dst: v3,

6762

};

6763

    let v5 = C::emit(ctx, &v4);

6764

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

6765

    // Rule at src/isa/x64/inst.isle line 3950.

6766

    return v6;

6767

6768

6769

// Generated as internal constructor for term xmm_rmr_imm_vex.

6770

pub fn constructor_xmm_rmr_imm_vex<C: Context>(

6771

    ctx: &mut C,

6772

    arg0: &AvxOpcode,

6773

    arg1: Xmm,

6774

    arg2: &XmmMem,

6775

    arg3: u8,

6776

) -> Xmm {

6777

    let v4 = C::temp_writable_xmm(ctx);

6778

    let v5 = MInst::XmmRmRImmVex {

6779

        op: arg0.clone(),

6780

        src1: arg1,

6781

        src2: arg2.clone(),

6782

        dst: v4,

6783

        imm: arg3,

6784

};

6785

    let v6 = C::emit(ctx, &v5);

6786

    let v7 = C::writable_xmm_to_xmm(ctx, v4);

6787

    // Rule at src/isa/x64/inst.isle line 3957.

6788

    return v7;

6789

6790

6791

// Generated as internal constructor for term xmm_rmr_vex3.

6792

pub fn constructor_xmm_rmr_vex3<C: Context>(

6793

    ctx: &mut C,

6794

    arg0: &AvxOpcode,

6795

    arg1: Xmm,

6796

    arg2: Xmm,

6797

    arg3: &XmmMem,

6798

) -> Xmm {

6799

    let v4 = C::temp_writable_xmm(ctx);

6800

    let v5 = MInst::XmmRmRVex3 {

6801

        op: arg0.clone(),

6802

        src1: arg1,

6803

        src2: arg2,

6804

        src3: arg3.clone(),

6805

        dst: v4,

6806

};

6807

    let v6 = C::emit(ctx, &v5);

6808

    let v7 = C::writable_xmm_to_xmm(ctx, v4);

6809

    // Rule at src/isa/x64/inst.isle line 3964.

6810

    return v7;

6811

6812

6813

// Generated as internal constructor for term x64_vfmadd213.

6814

pub fn constructor_x64_vfmadd213<C: Context>(

6815

    ctx: &mut C,

6816

    arg0: Type,

6817

    arg1: Xmm,

6818

    arg2: Xmm,

6819

    arg3: &XmmMem,

6820

) -> Xmm {

6821

    match arg0 {

6822

        F32 => {

6823

            let v5 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd213ss, arg1, arg2, arg3);

6824

            // Rule at src/isa/x64/inst.isle line 3971.

6825

            return v5;

6826

6827

        F64 => {

6828

            let v7 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd213sd, arg1, arg2, arg3);

6829

            // Rule at src/isa/x64/inst.isle line 3972.

6830

            return v7;

6831

6832

        F32X4 => {

6833

            let v9 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd213ps, arg1, arg2, arg3);

6834

            // Rule at src/isa/x64/inst.isle line 3973.

6835

            return v9;

6836

6837

        F64X2 => {

6838

            let v11 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd213pd, arg1, arg2, arg3);

6839

            // Rule at src/isa/x64/inst.isle line 3974.

6840

            return v11;

6841

6842

        _ => {}

6843

6844

    unreachable!(

6845

        "no rule matched for term {} at {}; should it be partial?",

6846

        "x64_vfmadd213", "src/isa/x64/inst.isle line 3970"

6847

6848

6849

6850

// Generated as internal constructor for term x64_vfmadd132.

6851

pub fn constructor_x64_vfmadd132<C: Context>(

6852

    ctx: &mut C,

6853

    arg0: Type,

6854

    arg1: Xmm,

6855

    arg2: Xmm,

6856

    arg3: &XmmMem,

6857

) -> Xmm {

6858

    match arg0 {

6859

        F32 => {

6860

            let v5 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd132ss, arg1, arg2, arg3);

6861

            // Rule at src/isa/x64/inst.isle line 3978.

6862

            return v5;

6863

6864

        F64 => {

6865

            let v7 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd132sd, arg1, arg2, arg3);

6866

            // Rule at src/isa/x64/inst.isle line 3979.

6867

            return v7;

6868

6869

        F32X4 => {

6870

            let v9 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd132ps, arg1, arg2, arg3);

6871

            // Rule at src/isa/x64/inst.isle line 3980.

6872

            return v9;

6873

6874

        F64X2 => {

6875

            let v11 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd132pd, arg1, arg2, arg3);

6876

            // Rule at src/isa/x64/inst.isle line 3981.

6877

            return v11;

6878

6879

        _ => {}

6880

6881

    unreachable!(

6882

        "no rule matched for term {} at {}; should it be partial?",

6883

        "x64_vfmadd132", "src/isa/x64/inst.isle line 3977"

6884

6885

6886

6887

// Generated as internal constructor for term x64_vfnmadd213.

6888

pub fn constructor_x64_vfnmadd213<C: Context>(

6889

    ctx: &mut C,

6890

    arg0: Type,

6891

    arg1: Xmm,

6892

    arg2: Xmm,

6893

    arg3: &XmmMem,

6894

) -> Xmm {

6895

    match arg0 {

6896

        F32 => {

6897

            let v5 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd213ss, arg1, arg2, arg3);

6898

            // Rule at src/isa/x64/inst.isle line 3985.

6899

            return v5;

6900

6901

        F64 => {

6902

            let v7 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd213sd, arg1, arg2, arg3);

6903

            // Rule at src/isa/x64/inst.isle line 3986.

6904

            return v7;

6905

6906

        F32X4 => {

6907

            let v9 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd213ps, arg1, arg2, arg3);

6908

            // Rule at src/isa/x64/inst.isle line 3987.

6909

            return v9;

6910

6911

        F64X2 => {

6912

            let v11 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd213pd, arg1, arg2, arg3);

6913

            // Rule at src/isa/x64/inst.isle line 3988.

6914

            return v11;

6915

6916

        _ => {}

6917

6918

    unreachable!(

6919

        "no rule matched for term {} at {}; should it be partial?",

6920

        "x64_vfnmadd213", "src/isa/x64/inst.isle line 3984"

6921

6922

6923

6924

// Generated as internal constructor for term x64_vfnmadd132.

6925

pub fn constructor_x64_vfnmadd132<C: Context>(

6926

    ctx: &mut C,

6927

    arg0: Type,

6928

    arg1: Xmm,

6929

    arg2: Xmm,

6930

    arg3: &XmmMem,

6931

) -> Xmm {

6932

    match arg0 {

6933

        F32 => {

6934

            let v5 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd132ss, arg1, arg2, arg3);

6935

            // Rule at src/isa/x64/inst.isle line 3992.

6936

            return v5;

6937

6938

        F64 => {

6939

            let v7 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd132sd, arg1, arg2, arg3);

6940

            // Rule at src/isa/x64/inst.isle line 3993.

6941

            return v7;

6942

6943

        F32X4 => {

6944

            let v9 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd132ps, arg1, arg2, arg3);

6945

            // Rule at src/isa/x64/inst.isle line 3994.

6946

            return v9;

6947

6948

        F64X2 => {

6949

            let v11 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd132pd, arg1, arg2, arg3);

6950

            // Rule at src/isa/x64/inst.isle line 3995.

6951

            return v11;

6952

6953

        _ => {}

6954

6955

    unreachable!(

6956

        "no rule matched for term {} at {}; should it be partial?",

6957

        "x64_vfnmadd132", "src/isa/x64/inst.isle line 3991"

6958

6959

6960

6961

// Generated as internal constructor for term x64_sqrtss.

6962

pub fn constructor_x64_sqrtss<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

6963

    let v3 = C::use_avx_simd(ctx);

6964

    if v3 == true {

6965

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vsqrtss, arg0);

6966

        // Rule at src/isa/x64/inst.isle line 4000.

6967

        return v5;

6968

6969

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Sqrtss, arg0);

6970

    // Rule at src/isa/x64/inst.isle line 3999.

6971

    return v2;

6972

6973

6974

// Generated as internal constructor for term x64_sqrtsd.

6975

pub fn constructor_x64_sqrtsd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

6976

    let v3 = C::use_avx_simd(ctx);

6977

    if v3 == true {

6978

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vsqrtsd, arg0);

6979

        // Rule at src/isa/x64/inst.isle line 4007.

6980

        return v5;

6981

6982

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Sqrtsd, arg0);

6983

    // Rule at src/isa/x64/inst.isle line 4006.

6984

    return v2;

6985

6986

6987

// Generated as internal constructor for term x64_sqrtps.

6988

pub fn constructor_x64_sqrtps<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

6989

    let v4 = C::use_avx_simd(ctx);

6990

    if v4 == true {

6991

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vsqrtps, arg0);

6992

        // Rule at src/isa/x64/inst.isle line 4014.

6993

        return v6;

6994

6995

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

6996

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Sqrtps, v2);

6997

    // Rule at src/isa/x64/inst.isle line 4013.

6998

    return v3;

6999

7000

7001

// Generated as internal constructor for term x64_sqrtpd.

7002

pub fn constructor_x64_sqrtpd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7003

    let v4 = C::use_avx_simd(ctx);

7004

    if v4 == true {

7005

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vsqrtpd, arg0);

7006

        // Rule at src/isa/x64/inst.isle line 4021.

7007

        return v6;

7008

7009

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7010

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Sqrtpd, v2);

7011

    // Rule at src/isa/x64/inst.isle line 4020.

7012

    return v3;

7013

7014

7015

// Generated as internal constructor for term x64_cvtss2sd.

7016

pub fn constructor_x64_cvtss2sd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7017

    let v3 = C::use_avx_simd(ctx);

7018

    if v3 == true {

7019

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtss2sd, arg0);

7020

        // Rule at src/isa/x64/inst.isle line 4028.

7021

        return v5;

7022

7023

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Cvtss2sd, arg0);

7024

    // Rule at src/isa/x64/inst.isle line 4027.

7025

    return v2;

7026

7027

7028

// Generated as internal constructor for term x64_cvtsd2ss.

7029

pub fn constructor_x64_cvtsd2ss<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7030

    let v3 = C::use_avx_simd(ctx);

7031

    if v3 == true {

7032

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtsd2ss, arg0);

7033

        // Rule at src/isa/x64/inst.isle line 4035.

7034

        return v5;

7035

7036

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Cvtsd2ss, arg0);

7037

    // Rule at src/isa/x64/inst.isle line 4034.

7038

    return v2;

7039

7040

7041

// Generated as internal constructor for term x64_cvtdq2ps.

7042

pub fn constructor_x64_cvtdq2ps<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7043

    let v4 = C::use_avx_simd(ctx);

7044

    if v4 == true {

7045

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtdq2ps, arg0);

7046

        // Rule at src/isa/x64/inst.isle line 4042.

7047

        return v6;

7048

7049

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7050

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvtdq2ps, v2);

7051

    // Rule at src/isa/x64/inst.isle line 4041.

7052

    return v3;

7053

7054

7055

// Generated as internal constructor for term x64_cvtps2pd.

7056

pub fn constructor_x64_cvtps2pd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7057

    let v4 = C::use_avx_simd(ctx);

7058

    if v4 == true {

7059

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtps2pd, arg0);

7060

        // Rule at src/isa/x64/inst.isle line 4049.

7061

        return v6;

7062

7063

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7064

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvtps2pd, v2);

7065

    // Rule at src/isa/x64/inst.isle line 4048.

7066

    return v3;

7067

7068

7069

// Generated as internal constructor for term x64_cvtpd2ps.

7070

pub fn constructor_x64_cvtpd2ps<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7071

    let v4 = C::use_avx_simd(ctx);

7072

    if v4 == true {

7073

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtpd2ps, arg0);

7074

        // Rule at src/isa/x64/inst.isle line 4056.

7075

        return v6;

7076

7077

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7078

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvtpd2ps, v2);

7079

    // Rule at src/isa/x64/inst.isle line 4055.

7080

    return v3;

7081

7082

7083

// Generated as internal constructor for term x64_cvtdq2pd.

7084

pub fn constructor_x64_cvtdq2pd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7085

    let v4 = C::use_avx_simd(ctx);

7086

    if v4 == true {

7087

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtdq2pd, arg0);

7088

        // Rule at src/isa/x64/inst.isle line 4063.

7089

        return v6;

7090

7091

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7092

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvtdq2pd, v2);

7093

    // Rule at src/isa/x64/inst.isle line 4062.

7094

    return v3;

7095

7096

7097

// Generated as internal constructor for term x64_cvtsi2ss.

7098

pub fn constructor_x64_cvtsi2ss<C: Context>(ctx: &mut C, arg0: Type, arg1: &GprMem) -> Xmm {

7099

    let v5 = C::use_avx_simd(ctx);

7100

    if v5 == true {

7101

        let v3 = &C::raw_operand_size_of_type(ctx, arg0);

7102

        let v7 = constructor_gpr_to_xmm_vex(ctx, &AvxOpcode::Vcvtsi2ss, arg1, v3);

7103

        // Rule at src/isa/x64/inst.isle line 4071.

7104

        return v7;

7105

7106

    let v3 = &C::raw_operand_size_of_type(ctx, arg0);

7107

    let v4 = constructor_gpr_to_xmm(ctx, &SseOpcode::Cvtsi2ss, arg1, v3);

7108

    // Rule at src/isa/x64/inst.isle line 4069.

7109

    return v4;

7110

7111

7112

// Generated as internal constructor for term x64_cvtsi2sd.

7113

pub fn constructor_x64_cvtsi2sd<C: Context>(ctx: &mut C, arg0: Type, arg1: &GprMem) -> Xmm {

7114

    let v5 = C::use_avx_simd(ctx);

7115

    if v5 == true {

7116

        let v3 = &C::raw_operand_size_of_type(ctx, arg0);

7117

        let v7 = constructor_gpr_to_xmm_vex(ctx, &AvxOpcode::Vcvtsi2sd, arg1, v3);

7118

        // Rule at src/isa/x64/inst.isle line 4079.

7119

        return v7;

7120

7121

    let v3 = &C::raw_operand_size_of_type(ctx, arg0);

7122

    let v4 = constructor_gpr_to_xmm(ctx, &SseOpcode::Cvtsi2sd, arg1, v3);

7123

    // Rule at src/isa/x64/inst.isle line 4077.

7124

    return v4;

7125

7126

7127

// Generated as internal constructor for term x64_cvttps2dq.

7128

pub fn constructor_x64_cvttps2dq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7129

    let v4 = C::use_avx_simd(ctx);

7130

    if v4 == true {

7131

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvttps2dq, arg0);

7132

        // Rule at src/isa/x64/inst.isle line 4087.

7133

        return v6;

7134

7135

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7136

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvttps2dq, v2);

7137

    // Rule at src/isa/x64/inst.isle line 4085.

7138

    return v3;

7139

7140

7141

// Generated as internal constructor for term x64_cvttpd2dq.

7142

pub fn constructor_x64_cvttpd2dq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7143

    let v4 = C::use_avx_simd(ctx);

7144

    if v4 == true {

7145

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvttpd2dq, arg0);

7146

        // Rule at src/isa/x64/inst.isle line 4095.

7147

        return v6;

7148

7149

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7150

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvttpd2dq, v2);

7151

    // Rule at src/isa/x64/inst.isle line 4093.

7152

    return v3;

7153

7154

7155

// Generated as internal constructor for term cvt_u64_to_float_seq.

7156

pub fn constructor_cvt_u64_to_float_seq<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Xmm {

7157

    let v2 = &C::raw_operand_size_of_type(ctx, arg0);

7158

    let v3 = C::temp_writable_xmm(ctx);

7159

    let v4 = C::temp_writable_gpr(ctx);

7160

    let v5 = C::temp_writable_gpr(ctx);

7161

    let v6 = MInst::CvtUint64ToFloatSeq {

7162

        dst_size: v2.clone(),

7163

        src: arg1,

7164

        dst: v3,

7165

        tmp_gpr1: v4,

7166

        tmp_gpr2: v5,

7167

};

7168

    let v7 = C::emit(ctx, &v6);

7169

    let v8 = C::writable_xmm_to_xmm(ctx, v3);

7170

    // Rule at src/isa/x64/inst.isle line 4100.

7171

    return v8;

7172

7173

7174

// Generated as internal constructor for term cvt_float_to_uint_seq.

7175

pub fn constructor_cvt_float_to_uint_seq<C: Context>(

7176

    ctx: &mut C,

7177

    arg0: Type,

7178

    arg1: Value,

7179

    arg2: bool,

7180

) -> Gpr {

7181

    let v4 = &C::raw_operand_size_of_type(ctx, arg0);

7182

    let v2 = C::value_type(ctx, arg1);

7183

    let v5 = &C::raw_operand_size_of_type(ctx, v2);

7184

    let v6 = C::temp_writable_gpr(ctx);

7185

    let v7 = C::temp_writable_xmm(ctx);

7186

    let v8 = C::temp_writable_xmm(ctx);

7187

    let v9 = C::temp_writable_gpr(ctx);

7188

    let v10 = constructor_put_in_xmm(ctx, arg1);

7189

    let v11 = MInst::CvtFloatToUintSeq {

7190

        dst_size: v4.clone(),

7191

        src_size: v5.clone(),

7192

        is_saturating: arg2,

7193

        src: v10,

7194

        dst: v6,

7195

        tmp_gpr: v9,

7196

        tmp_xmm: v7,

7197

        tmp_xmm2: v8,

7198

};

7199

    let v12 = C::emit(ctx, &v11);

7200

    let v13 = C::writable_gpr_to_gpr(ctx, v6);

7201

    // Rule at src/isa/x64/inst.isle line 4109.

7202

    return v13;

7203

7204

7205

// Generated as internal constructor for term cvt_float_to_sint_seq.

7206

pub fn constructor_cvt_float_to_sint_seq<C: Context>(

7207

    ctx: &mut C,

7208

    arg0: Type,

7209

    arg1: Value,

7210

    arg2: bool,

7211

) -> Gpr {

7212

    let v4 = &C::raw_operand_size_of_type(ctx, arg0);

7213

    let v2 = C::value_type(ctx, arg1);

7214

    let v5 = &C::raw_operand_size_of_type(ctx, v2);

7215

    let v6 = C::temp_writable_gpr(ctx);

7216

    let v7 = C::temp_writable_xmm(ctx);

7217

    let v8 = C::temp_writable_gpr(ctx);

7218

    let v9 = constructor_put_in_xmm(ctx, arg1);

7219

    let v10 = MInst::CvtFloatToSintSeq {

7220

        dst_size: v4.clone(),

7221

        src_size: v5.clone(),

7222

        is_saturating: arg2,

7223

        src: v9,

7224

        dst: v6,

7225

        tmp_gpr: v8,

7226

        tmp_xmm: v7,

7227

};

7228

    let v11 = C::emit(ctx, &v10);

7229

    let v12 = C::writable_gpr_to_gpr(ctx, v6);

7230

    // Rule at src/isa/x64/inst.isle line 4121.

7231

    return v12;

7232

7233

7234

// Generated as internal constructor for term x64_pcmpeq.

7235

pub fn constructor_x64_pcmpeq<C: Context>(

7236

    ctx: &mut C,

7237

    arg0: Type,

7238

    arg1: Xmm,

7239

    arg2: &XmmMem,

7240

) -> Xmm {

7241

    match arg0 {

7242

        I8X16 => {

7243

            let v3 = constructor_x64_pcmpeqb(ctx, arg1, arg2);

7244

            // Rule at src/isa/x64/inst.isle line 4139.

7245

            return v3;

7246

7247

        I16X8 => {

7248

            let v4 = constructor_x64_pcmpeqw(ctx, arg1, arg2);

7249

            // Rule at src/isa/x64/inst.isle line 4140.

7250

            return v4;

7251

7252

        I32X4 => {

7253

            let v5 = constructor_x64_pcmpeqd(ctx, arg1, arg2);

7254

            // Rule at src/isa/x64/inst.isle line 4141.

7255

            return v5;

7256

7257

        I64X2 => {

7258

            let v6 = constructor_x64_pcmpeqq(ctx, arg1, arg2);

7259

            // Rule at src/isa/x64/inst.isle line 4142.

7260

            return v6;

7261

7262

        _ => {}

7263

7264

    unreachable!(

7265

        "no rule matched for term {} at {}; should it be partial?",

7266

        "x64_pcmpeq", "src/isa/x64/inst.isle line 4138"

7267

7268

7269

7270

// Generated as internal constructor for term x64_pcmpeqb.

7271

pub fn constructor_x64_pcmpeqb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7272

    let v5 = C::use_avx_simd(ctx);

7273

    if v5 == true {

7274

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7275

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpeqb, arg0, v7);

7276

        // Rule at src/isa/x64/inst.isle line 4146.

7277

        return v8;

7278

7279

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

7280

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpeqb, arg0, v3);

7281

    // Rule at src/isa/x64/inst.isle line 4145.

7282

    return v4;

7283

7284

7285

// Generated as internal constructor for term x64_pcmpeqw.

7286

pub fn constructor_x64_pcmpeqw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7287

    let v5 = C::use_avx_simd(ctx);

7288

    if v5 == true {

7289

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7290

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpeqw, arg0, v7);

7291

        // Rule at src/isa/x64/inst.isle line 4151.

7292

        return v8;

7293

7294

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

7295

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpeqw, arg0, v3);

7296

    // Rule at src/isa/x64/inst.isle line 4150.

7297

    return v4;

7298

7299

7300

// Generated as internal constructor for term x64_pcmpeqd.

7301

pub fn constructor_x64_pcmpeqd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7302

    let v5 = C::use_avx_simd(ctx);

7303

    if v5 == true {

7304

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7305

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpeqd, arg0, v7);

7306

        // Rule at src/isa/x64/inst.isle line 4156.

7307

        return v8;

7308

7309

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

7310

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpeqd, arg0, v3);

7311

    // Rule at src/isa/x64/inst.isle line 4155.

7312

    return v4;

7313

7314

7315

// Generated as internal constructor for term x64_pcmpeqq.

7316

pub fn constructor_x64_pcmpeqq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7317

    let v5 = C::use_avx_simd(ctx);

7318

    if v5 == true {

7319

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7320

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpeqq, arg0, v7);

7321

        // Rule at src/isa/x64/inst.isle line 4161.

7322

        return v8;

7323

7324

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

7325

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpeqq, arg0, v3);

7326

    // Rule at src/isa/x64/inst.isle line 4160.

7327

    return v4;

7328

7329

7330

// Generated as internal constructor for term x64_pcmpgt.

7331

pub fn constructor_x64_pcmpgt<C: Context>(

7332

    ctx: &mut C,

7333

    arg0: Type,

7334

    arg1: Xmm,

7335

    arg2: &XmmMem,

7336

) -> Xmm {

7337

    match arg0 {

7338

        I8X16 => {

7339

            let v3 = constructor_x64_pcmpgtb(ctx, arg1, arg2);

7340

            // Rule at src/isa/x64/inst.isle line 4167.

7341

            return v3;

7342

7343

        I16X8 => {

7344

            let v4 = constructor_x64_pcmpgtw(ctx, arg1, arg2);

7345

            // Rule at src/isa/x64/inst.isle line 4168.

7346

            return v4;

7347

7348

        I32X4 => {

7349

            let v5 = constructor_x64_pcmpgtd(ctx, arg1, arg2);

7350

            // Rule at src/isa/x64/inst.isle line 4169.

7351

            return v5;

7352

7353

        I64X2 => {

7354

            let v6 = constructor_x64_pcmpgtq(ctx, arg1, arg2);

7355

            // Rule at src/isa/x64/inst.isle line 4170.

7356

            return v6;

7357

7358

        _ => {}

7359

7360

    unreachable!(

7361

        "no rule matched for term {} at {}; should it be partial?",

7362

        "x64_pcmpgt", "src/isa/x64/inst.isle line 4166"

7363

7364

7365

7366

// Generated as internal constructor for term x64_pcmpgtb.

7367

pub fn constructor_x64_pcmpgtb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7368

    let v5 = C::use_avx_simd(ctx);

7369

    if v5 == true {

7370

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7371

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpgtb, arg0, v7);

7372

        // Rule at src/isa/x64/inst.isle line 4174.

7373

        return v8;

7374

7375

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

7376

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpgtb, arg0, v3);

7377

    // Rule at src/isa/x64/inst.isle line 4173.

7378

    return v4;

7379

7380

7381

// Generated as internal constructor for term x64_pcmpgtw.

7382

pub fn constructor_x64_pcmpgtw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7383

    let v5 = C::use_avx_simd(ctx);

7384

    if v5 == true {

7385

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7386

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpgtw, arg0, v7);

7387

        // Rule at src/isa/x64/inst.isle line 4179.

7388

        return v8;

7389

7390

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

7391

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpgtw, arg0, v3);

7392

    // Rule at src/isa/x64/inst.isle line 4178.

7393

    return v4;

7394

7395

7396

// Generated as internal constructor for term x64_pcmpgtd.

7397

pub fn constructor_x64_pcmpgtd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7398

    let v5 = C::use_avx_simd(ctx);

7399

    if v5 == true {

7400

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7401

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpgtd, arg0, v7);

7402

        // Rule at src/isa/x64/inst.isle line 4184.

7403

        return v8;

7404

7405

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

7406

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpgtd, arg0, v3);

7407

    // Rule at src/isa/x64/inst.isle line 4183.

7408

    return v4;

7409

7410

7411

// Generated as internal constructor for term x64_pcmpgtq.

7412

pub fn constructor_x64_pcmpgtq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7413

    let v5 = C::use_avx_simd(ctx);

7414

    if v5 == true {

7415

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7416

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpgtq, arg0, v7);

7417

        // Rule at src/isa/x64/inst.isle line 4189.

7418

        return v8;

7419

7420

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

7421

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpgtq, arg0, v3);

7422

    // Rule at src/isa/x64/inst.isle line 4188.

7423

    return v4;

7424

7425

7426

// Generated as internal constructor for term alu_rm.

7427

pub fn constructor_alu_rm<C: Context>(

7428

    ctx: &mut C,

7429

    arg0: Type,

7430

    arg1: &AluRmiROpcode,

7431

    arg2: &Amode,

7432

    arg3: Gpr,

7433

) -> SideEffectNoResult {

7434

    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);

7435

    let v5 = &C::amode_to_synthetic_amode(ctx, arg2);

7436

    let v6 = MInst::AluRM {

7437

        size: v4.clone(),

7438

        op: arg1.clone(),

7439

        src1_dst: v5.clone(),

7440

        src2: arg3,

7441

};

7442

    let v7 = SideEffectNoResult::Inst { inst: v6 };

7443

    // Rule at src/isa/x64/inst.isle line 4195.

7444

    return v7;

7445

7446

7447

// Generated as internal constructor for term x64_add_mem.

7448

pub fn constructor_x64_add_mem<C: Context>(

7449

    ctx: &mut C,

7450

    arg0: Type,

7451

    arg1: &Amode,

7452

    arg2: Gpr,

7453

) -> SideEffectNoResult {

7454

    let v4 = &constructor_alu_rm(ctx, arg0, &AluRmiROpcode::Add, arg1, arg2);

7455

    // Rule at src/isa/x64/inst.isle line 4200.

7456

    return v4.clone();

7457

7458

7459

// Generated as internal constructor for term x64_sub_mem.

7460

pub fn constructor_x64_sub_mem<C: Context>(

7461

    ctx: &mut C,

7462

    arg0: Type,

7463

    arg1: &Amode,

7464

    arg2: Gpr,

7465

) -> SideEffectNoResult {

7466

    let v4 = &constructor_alu_rm(ctx, arg0, &AluRmiROpcode::Sub, arg1, arg2);

7467

    // Rule at src/isa/x64/inst.isle line 4204.

7468

    return v4.clone();

7469

7470

7471

// Generated as internal constructor for term x64_and_mem.

7472

pub fn constructor_x64_and_mem<C: Context>(

7473

    ctx: &mut C,

7474

    arg0: Type,

7475

    arg1: &Amode,

7476

    arg2: Gpr,

7477

) -> SideEffectNoResult {

7478

    let v4 = &constructor_alu_rm(ctx, arg0, &AluRmiROpcode::And, arg1, arg2);

7479

    // Rule at src/isa/x64/inst.isle line 4208.

7480

    return v4.clone();

7481

7482

7483

// Generated as internal constructor for term x64_or_mem.

7484

pub fn constructor_x64_or_mem<C: Context>(

7485

    ctx: &mut C,

7486

    arg0: Type,

7487

    arg1: &Amode,

7488

    arg2: Gpr,

7489

) -> SideEffectNoResult {

7490

    let v4 = &constructor_alu_rm(ctx, arg0, &AluRmiROpcode::Or, arg1, arg2);

7491

    // Rule at src/isa/x64/inst.isle line 4212.

7492

    return v4.clone();

7493

7494

7495

// Generated as internal constructor for term x64_xor_mem.

7496

pub fn constructor_x64_xor_mem<C: Context>(

7497

    ctx: &mut C,

7498

    arg0: Type,

7499

    arg1: &Amode,

7500

    arg2: Gpr,

7501

) -> SideEffectNoResult {

7502

    let v4 = &constructor_alu_rm(ctx, arg0, &AluRmiROpcode::Xor, arg1, arg2);

7503

    // Rule at src/isa/x64/inst.isle line 4216.

7504

    return v4.clone();

7505

7506

7507

// Generated as internal constructor for term trap_if.

7508

pub fn constructor_trap_if<C: Context>(ctx: &mut C, arg0: &CC, arg1: &TrapCode) -> ConsumesFlags {

7509

    let v2 = MInst::TrapIf {

7510

        cc: arg0.clone(),

7511

        trap_code: arg1.clone(),

7512

};

7513

    let v3 = ConsumesFlags::ConsumesFlagsSideEffect { inst: v2 };

7514

    // Rule at src/isa/x64/inst.isle line 4221.

7515

    return v3;

7516

7517

7518

// Generated as internal constructor for term trap_if_and.

7519

pub fn constructor_trap_if_and<C: Context>(

7520

    ctx: &mut C,

7521

    arg0: &CC,

7522

    arg1: &CC,

7523

    arg2: &TrapCode,

7524

) -> ConsumesFlags {

7525

    let v3 = MInst::TrapIfAnd {

7526

        cc1: arg0.clone(),

7527

        cc2: arg1.clone(),

7528

        trap_code: arg2.clone(),

7529

};

7530

    let v4 = ConsumesFlags::ConsumesFlagsSideEffect { inst: v3 };

7531

    // Rule at src/isa/x64/inst.isle line 4226.

7532

    return v4;

7533

7534

7535

// Generated as internal constructor for term trap_if_or.

7536

pub fn constructor_trap_if_or<C: Context>(

7537

    ctx: &mut C,

7538

    arg0: &CC,

7539

    arg1: &CC,

7540

    arg2: &TrapCode,

7541

) -> ConsumesFlags {

7542

    let v3 = MInst::TrapIfOr {

7543

        cc1: arg0.clone(),

7544

        cc2: arg1.clone(),

7545

        trap_code: arg2.clone(),

7546

};

7547

    let v4 = ConsumesFlags::ConsumesFlagsSideEffect { inst: v3 };

7548

    // Rule at src/isa/x64/inst.isle line 4231.

7549

    return v4;

7550

7551

7552

// Generated as internal constructor for term trap_if_icmp.

7553

pub fn constructor_trap_if_icmp<C: Context>(

7554

    ctx: &mut C,

7555

    arg0: &IcmpCondResult,

7556

    arg1: &TrapCode,

7557

) -> SideEffectNoResult {

7558

    if let &IcmpCondResult::Condition {

7559

        producer: ref v1,

7560

        cc: ref v2,

7561

    } = arg0

7562

7563

        let v4 = &constructor_trap_if(ctx, v2, arg1);

7564

        let v5 = &constructor_with_flags_side_effect(ctx, v1, v4);

7565

        // Rule at src/isa/x64/inst.isle line 4235.

7566

        return v5.clone();

7567

7568

    unreachable!(

7569

        "no rule matched for term {} at {}; should it be partial?",

7570

        "trap_if_icmp", "src/isa/x64/inst.isle line 4234"

7571

7572

7573

7574

// Generated as internal constructor for term trap_if_fcmp.

7575

pub fn constructor_trap_if_fcmp<C: Context>(

7576

    ctx: &mut C,

7577

    arg0: &FcmpCondResult,

7578

    arg1: &TrapCode,

7579

) -> SideEffectNoResult {

7580

    match arg0 {

7581

        &FcmpCondResult::Condition {

7582

            producer: ref v1,

7583

            cc: ref v2,

7584

        } => {

7585

            let v4 = &constructor_trap_if(ctx, v2, arg1);

7586

            let v5 = &constructor_with_flags_side_effect(ctx, v1, v4);

7587

            // Rule at src/isa/x64/inst.isle line 4239.

7588

            return v5.clone();

7589

7590

        &FcmpCondResult::AndCondition {

7591

            producer: ref v6,

7592

            cc1: ref v7,

7593

            cc2: ref v8,

7594

        } => {

7595

            let v9 = &constructor_trap_if_and(ctx, v7, v8, arg1);

7596

            let v10 = &constructor_with_flags_side_effect(ctx, v6, v9);

7597

            // Rule at src/isa/x64/inst.isle line 4241.

7598

            return v10.clone();

7599

7600

        &FcmpCondResult::OrCondition {

7601

            producer: ref v11,

7602

            cc1: ref v12,

7603

            cc2: ref v13,

7604

        } => {

7605

            let v14 = &constructor_trap_if_or(ctx, v12, v13, arg1);

7606

            let v15 = &constructor_with_flags_side_effect(ctx, v11, v14);

7607

            // Rule at src/isa/x64/inst.isle line 4243.

7608

            return v15.clone();

7609

7610

        _ => {}

7611

7612

    unreachable!(

7613

        "no rule matched for term {} at {}; should it be partial?",

7614

        "trap_if_fcmp", "src/isa/x64/inst.isle line 4238"

7615

7616

7617

7618

// Generated as internal constructor for term x64_movddup.

7619

pub fn constructor_x64_movddup<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7620

    let v3 = C::use_avx_simd(ctx);

7621

    if v3 == true {

7622

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovddup, arg0);

7623

        // Rule at src/isa/x64/inst.isle line 4250.

7624

        return v5;

7625

7626

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movddup, arg0);

7627

    // Rule at src/isa/x64/inst.isle line 4248.

7628

    return v2;

7629

7630

7631

// Generated as internal constructor for term x64_vpbroadcastb.

7632

pub fn constructor_x64_vpbroadcastb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7633

    let v2 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpbroadcastb, arg0);

7634

    // Rule at src/isa/x64/inst.isle line 4256.

7635

    return v2;

7636

7637

7638

// Generated as internal constructor for term x64_vpbroadcastw.

7639

pub fn constructor_x64_vpbroadcastw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7640

    let v2 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpbroadcastw, arg0);

7641

    // Rule at src/isa/x64/inst.isle line 4261.

7642

    return v2;

7643

7644

7645

// Generated as internal constructor for term x64_vpbroadcastd.

7646

pub fn constructor_x64_vpbroadcastd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7647

    let v2 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpbroadcastd, arg0);

7648

    // Rule at src/isa/x64/inst.isle line 4266.

7649

    return v2;

7650

7651

7652

// Generated as internal constructor for term x64_vbroadcastss.

7653

pub fn constructor_x64_vbroadcastss<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7654

    let v2 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vbroadcastss, arg0);

7655

    // Rule at src/isa/x64/inst.isle line 4271.

7656

    return v2;

7657

7658

7659

// Generated as internal constructor for term jmp_known.

7660

pub fn constructor_jmp_known<C: Context>(ctx: &mut C, arg0: MachLabel) -> SideEffectNoResult {

7661

    let v1 = MInst::JmpKnown { dst: arg0 };

7662

    let v2 = SideEffectNoResult::Inst { inst: v1 };

7663

    // Rule at src/isa/x64/inst.isle line 4278.

7664

    return v2;

7665

7666

7667

// Generated as internal constructor for term jmp_if.

7668

pub fn constructor_jmp_if<C: Context>(ctx: &mut C, arg0: &CC, arg1: MachLabel) -> ConsumesFlags {

7669

    let v2 = MInst::JmpIf {

7670

        cc: arg0.clone(),

7671

        taken: arg1,

7672

};

7673

    let v3 = ConsumesFlags::ConsumesFlagsSideEffect { inst: v2 };

7674

    // Rule at src/isa/x64/inst.isle line 4282.

7675

    return v3;

7676

7677

7678

// Generated as internal constructor for term jmp_cond.

7679

pub fn constructor_jmp_cond<C: Context>(

7680

    ctx: &mut C,

7681

    arg0: &CC,

7682

    arg1: MachLabel,

7683

    arg2: MachLabel,

7684

) -> ConsumesFlags {

7685

    let v3 = MInst::JmpCond {

7686

        cc: arg0.clone(),

7687

        taken: arg1,

7688

        not_taken: arg2,

7689

};

7690

    let v4 = ConsumesFlags::ConsumesFlagsSideEffect { inst: v3 };

7691

    // Rule at src/isa/x64/inst.isle line 4287.

7692

    return v4;

7693

7694

7695

// Generated as internal constructor for term jmp_cond_icmp.

7696

pub fn constructor_jmp_cond_icmp<C: Context>(

7697

    ctx: &mut C,

7698

    arg0: &IcmpCondResult,

7699

    arg1: MachLabel,

7700

    arg2: MachLabel,

7701

) -> SideEffectNoResult {

7702

    if let &IcmpCondResult::Condition {

7703

        producer: ref v1,

7704

        cc: ref v2,

7705

    } = arg0

7706

7707

        let v5 = &constructor_jmp_cond(ctx, v2, arg1, arg2);

7708

        let v6 = &constructor_with_flags_side_effect(ctx, v1, v5);

7709

        // Rule at src/isa/x64/inst.isle line 4292.

7710

        return v6.clone();

7711

7712

    unreachable!(

7713

        "no rule matched for term {} at {}; should it be partial?",

7714

        "jmp_cond_icmp", "src/isa/x64/inst.isle line 4291"

7715

7716

7717

7718

// Generated as internal constructor for term jmp_cond_fcmp.

7719

pub fn constructor_jmp_cond_fcmp<C: Context>(

7720

    ctx: &mut C,

7721

    arg0: &FcmpCondResult,

7722

    arg1: MachLabel,

7723

    arg2: MachLabel,

7724

) -> SideEffectNoResult {

7725

    match arg0 {

7726

        &FcmpCondResult::Condition {

7727

            producer: ref v1,

7728

            cc: ref v2,

7729

        } => {

7730

            let v5 = &constructor_jmp_cond(ctx, v2, arg1, arg2);

7731

            let v6 = &constructor_with_flags_side_effect(ctx, v1, v5);

7732

            // Rule at src/isa/x64/inst.isle line 4297.

7733

            return v6.clone();

7734

7735

        &FcmpCondResult::AndCondition {

7736

            producer: ref v7,

7737

            cc1: ref v8,

7738

            cc2: ref v9,

7739

        } => {

7740

            let v10 = &C::cc_invert(ctx, v8);

7741

            let v11 = &constructor_jmp_if(ctx, v10, arg2);

7742

            let v12 = &C::cc_invert(ctx, v9);

7743

            let v13 = &constructor_jmp_cond(ctx, v12, arg2, arg1);

7744

            let v14 = &constructor_consumes_flags_concat(ctx, v11, v13);

7745

            let v15 = &constructor_with_flags_side_effect(ctx, v7, v14);

7746

            // Rule at src/isa/x64/inst.isle line 4299.

7747

            return v15.clone();

7748

7749

        &FcmpCondResult::OrCondition {

7750

            producer: ref v16,

7751

            cc1: ref v17,

7752

            cc2: ref v18,

7753

        } => {

7754

            let v19 = &constructor_jmp_if(ctx, v17, arg1);

7755

            let v20 = &constructor_jmp_cond(ctx, v18, arg1, arg2);

7756

            let v21 = &constructor_consumes_flags_concat(ctx, v19, v20);

7757

            let v22 = &constructor_with_flags_side_effect(ctx, v16, v21);

7758

            // Rule at src/isa/x64/inst.isle line 4304.

7759

            return v22.clone();

7760

7761

        _ => {}

7762

7763

    unreachable!(

7764

        "no rule matched for term {} at {}; should it be partial?",

7765

        "jmp_cond_fcmp", "src/isa/x64/inst.isle line 4296"

7766

7767

7768

7769

// Generated as internal constructor for term jmp_table_seq.

7770

pub fn constructor_jmp_table_seq<C: Context>(

7771

    ctx: &mut C,

7772

    arg0: Type,

7773

    arg1: Gpr,

7774

    arg2: MachLabel,

7775

    arg3: &BoxVecMachLabel,

7776

) -> SideEffectNoResult {

7777

    let v4 = C::temp_writable_gpr(ctx);

7778

    let v5 = C::temp_writable_gpr(ctx);

7779

    let v6 = C::gpr_to_reg(ctx, arg1);

7780

    let v7 = C::writable_gpr_to_reg(ctx, v4);

7781

    let v8 = C::writable_gpr_to_reg(ctx, v5);

7782

    let v9 = MInst::JmpTableSeq {

7783

        idx: v6,

7784

        tmp1: v7,

7785

        tmp2: v8,

7786

        default_target: arg2,

7787

        targets: arg3.clone(),

7788

};

7789

    let v10 = SideEffectNoResult::Inst { inst: v9 };

7790

    // Rule at src/isa/x64/inst.isle line 4324.

7791

    return v10;

7792

7793

7794

// Generated as internal constructor for term icmp_cond_result.

7795

pub fn constructor_icmp_cond_result<C: Context>(

7796

    ctx: &mut C,

7797

    arg0: &ProducesFlags,

7798

    arg1: &CC,

7799

) -> IcmpCondResult {

7800

    let v2 = IcmpCondResult::Condition {

7801

        producer: arg0.clone(),

7802

        cc: arg1.clone(),

7803

};

7804

    // Rule at src/isa/x64/inst.isle line 4362.

7805

    return v2;

7806

7807

7808

// Generated as internal constructor for term invert_icmp_cond_result.

7809

pub fn constructor_invert_icmp_cond_result<C: Context>(

7810

    ctx: &mut C,

7811

    arg0: &IcmpCondResult,

7812

) -> IcmpCondResult {

7813

    if let &IcmpCondResult::Condition {

7814

        producer: ref v1,

7815

        cc: ref v2,

7816

    } = arg0

7817

7818

        let v3 = &C::cc_invert(ctx, v2);

7819

        let v4 = &constructor_icmp_cond_result(ctx, v1, v3);

7820

        // Rule at src/isa/x64/inst.isle line 4365.

7821

        return v4.clone();

7822

7823

    unreachable!(

7824

        "no rule matched for term {} at {}; should it be partial?",

7825

        "invert_icmp_cond_result", "src/isa/x64/inst.isle line 4364"

7826

7827

7828

7829

// Generated as internal constructor for term lower_icmp_bool.

7830

pub fn constructor_lower_icmp_bool<C: Context>(ctx: &mut C, arg0: &IcmpCondResult) -> ValueRegs {

7831

    if let &IcmpCondResult::Condition {

7832

        producer: ref v1,

7833

        cc: ref v2,

7834

    } = arg0

7835

7836

        let v3 = &constructor_x64_setcc(ctx, v2);

7837

        let v4 = constructor_with_flags(ctx, v1, v3);

7838

        // Rule at src/isa/x64/inst.isle line 4370.

7839

        return v4;

7840

7841

    unreachable!(

7842

        "no rule matched for term {} at {}; should it be partial?",

7843

        "lower_icmp_bool", "src/isa/x64/inst.isle line 4369"

7844

7845

7846

7847

// Generated as internal constructor for term select_icmp.

7848

pub fn constructor_select_icmp<C: Context>(

7849

    ctx: &mut C,

7850

    arg0: &IcmpCondResult,

7851

    arg1: Value,

7852

    arg2: Value,

7853

) -> ValueRegs {

7854

    if let &IcmpCondResult::Condition {

7855

        producer: ref v1,

7856

        cc: ref v2,

7857

    } = arg0

7858

7859

        let v4 = C::value_type(ctx, arg1);

7860

        let v5 = &C::type_register_class(ctx, v4);

7861

        if let Some(v6) = v5 {

7862

            if let &RegisterClass::Gpr {

7863

                single_register: v7,

7864

            } = v6

7865

7866

                if v7 == true {

7867

                    let v9 = constructor_put_in_gpr(ctx, arg1);

7868

                    let v10 = &C::gpr_to_gpr_mem(ctx, v9);

7869

                    let v11 = constructor_put_in_gpr(ctx, arg2);

7870

                    let v12 = &constructor_cmove(ctx, v4, v2, v10, v11);

7871

                    let v13 = constructor_with_flags(ctx, v1, v12);

7872

                    // Rule at src/isa/x64/inst.isle line 4379.

7873

                    return v13;

7874

7875

7876

7877

        let v14 = &constructor_cmove_from_values(ctx, v4, v2, arg1, arg2);

7878

        let v15 = constructor_with_flags(ctx, v1, v14);

7879

        // Rule at src/isa/x64/inst.isle line 4383.

7880

        return v15;

7881

7882

    unreachable!(

7883

        "no rule matched for term {} at {}; should it be partial?",

7884

        "select_icmp", "src/isa/x64/inst.isle line 4374"

7885

7886

7887

7888

// Generated as internal constructor for term emit_cmp.

7889

pub fn constructor_emit_cmp<C: Context>(

7890

    ctx: &mut C,

7891

    arg0: &IntCC,

7892

    arg1: Value,

7893

    arg2: Value,

7894

) -> IcmpCondResult {

7895

    let v2 = C::value_type(ctx, arg1);

7896

    if v2 == I128 {

7897

        match arg0 {

7898

            &IntCC::Equal => {

7899

                let v44 = C::put_in_regs(ctx, arg1);

7900

                let v46 = constructor_value_regs_get_gpr(ctx, v44, 0x0);

7901

                let v47 = C::put_in_regs(ctx, arg1);

7902

                let v49 = constructor_value_regs_get_gpr(ctx, v47, 0x1);

7903

                let v50 = C::put_in_regs(ctx, arg2);

7904

                let v51 = constructor_value_regs_get_gpr(ctx, v50, 0x0);

7905

                let v52 = C::put_in_regs(ctx, arg2);

7906

                let v53 = constructor_value_regs_get_gpr(ctx, v52, 0x1);

7907

                let v55 = &C::gpr_to_gpr_mem_imm(ctx, v51);

7908

                let v56 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v55, v46);

7909

                let v58 = &constructor_x64_setcc(ctx, &CC::Z);

7910

                let v59 = constructor_with_flags_reg(ctx, v56, v58);

7911

                let v60 = &C::gpr_to_gpr_mem_imm(ctx, v53);

7912

                let v61 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v60, v49);

7913

                let v62 = &constructor_x64_setcc(ctx, &CC::Z);

7914

                let v63 = constructor_with_flags_reg(ctx, v61, v62);

7915

                let v65 = C::gpr_new(ctx, v59);

7916

                let v66 = &constructor_reg_to_gpr_mem_imm(ctx, v63);

7917

                let v67 = constructor_x64_and(ctx, I64, v65, v66);

7918

                let v68 = C::gpr_to_reg(ctx, v67);

7919

                let v70 = RegMemImm::Imm { simm32: 0x1 };

7920

                let v71 = &C::gpr_mem_imm_new(ctx, &v70);

7921

                let v72 = C::gpr_new(ctx, v68);

7922

                let v73 = &constructor_x64_test(ctx, &OperandSize::Size64, v71, v72);

7923

                let v75 = &constructor_icmp_cond_result(ctx, v73, &CC::NZ);

7924

                // Rule at src/isa/x64/inst.isle line 4415.

7925

                return v75.clone();

7926

7927

            &IntCC::NotEqual => {

7928

                let v44 = C::put_in_regs(ctx, arg1);

7929

                let v46 = constructor_value_regs_get_gpr(ctx, v44, 0x0);

7930

                let v47 = C::put_in_regs(ctx, arg1);

7931

                let v49 = constructor_value_regs_get_gpr(ctx, v47, 0x1);

7932

                let v50 = C::put_in_regs(ctx, arg2);

7933

                let v51 = constructor_value_regs_get_gpr(ctx, v50, 0x0);

7934

                let v52 = C::put_in_regs(ctx, arg2);

7935

                let v53 = constructor_value_regs_get_gpr(ctx, v52, 0x1);

7936

                let v55 = &C::gpr_to_gpr_mem_imm(ctx, v51);

7937

                let v56 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v55, v46);

7938

                let v76 = &constructor_x64_setcc(ctx, &CC::NZ);

7939

                let v77 = constructor_with_flags_reg(ctx, v56, v76);

7940

                let v60 = &C::gpr_to_gpr_mem_imm(ctx, v53);

7941

                let v61 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v60, v49);

7942

                let v78 = &constructor_x64_setcc(ctx, &CC::NZ);

7943

                let v79 = constructor_with_flags_reg(ctx, v61, v78);

7944

                let v80 = C::gpr_new(ctx, v77);

7945

                let v81 = &constructor_reg_to_gpr_mem_imm(ctx, v79);

7946

                let v82 = constructor_x64_or(ctx, I64, v80, v81);

7947

                let v83 = C::gpr_to_reg(ctx, v82);

7948

                let v70 = RegMemImm::Imm { simm32: 0x1 };

7949

                let v71 = &C::gpr_mem_imm_new(ctx, &v70);

7950

                let v84 = C::gpr_new(ctx, v83);

7951

                let v85 = &constructor_x64_test(ctx, &OperandSize::Size64, v71, v84);

7952

                let v86 = &constructor_icmp_cond_result(ctx, v85, &CC::NZ);

7953

                // Rule at src/isa/x64/inst.isle line 4436.

7954

                return v86.clone();

7955

7956

            _ => {}

7957

7958

        let v44 = C::put_in_regs(ctx, arg1);

7959

        let v46 = constructor_value_regs_get_gpr(ctx, v44, 0x0);

7960

        let v47 = C::put_in_regs(ctx, arg1);

7961

        let v49 = constructor_value_regs_get_gpr(ctx, v47, 0x1);

7962

        let v50 = C::put_in_regs(ctx, arg2);

7963

        let v51 = constructor_value_regs_get_gpr(ctx, v50, 0x0);

7964

        let v52 = C::put_in_regs(ctx, arg2);

7965

        let v53 = constructor_value_regs_get_gpr(ctx, v52, 0x1);

7966

        let v87 = &C::gpr_to_gpr_mem_imm(ctx, v53);

7967

        let v88 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v87, v49);

7968

        let v89 = &C::intcc_without_eq(ctx, arg0);

7969

        let v90 = &C::intcc_to_cc(ctx, v89);

7970

        let v91 = &constructor_x64_setcc(ctx, v90);

7971

        let v92 = &constructor_x64_setcc(ctx, &CC::Z);

7972

        let v93 = &constructor_consumes_flags_concat(ctx, v91, v92);

7973

        let v94 = constructor_with_flags(ctx, v88, v93);

7974

        let v95 = C::value_regs_get(ctx, v94, 0x0);

7975

        let v96 = C::value_regs_get(ctx, v94, 0x1);

7976

        let v97 = &C::gpr_to_gpr_mem_imm(ctx, v51);

7977

        let v98 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v97, v46);

7978

        let v99 = &C::intcc_unsigned(ctx, arg0);

7979

        let v100 = &C::intcc_to_cc(ctx, v99);

7980

        let v101 = &constructor_x64_setcc(ctx, v100);

7981

        let v102 = constructor_with_flags_reg(ctx, v98, v101);

7982

        let v103 = C::gpr_new(ctx, v96);

7983

        let v104 = &constructor_reg_to_gpr_mem_imm(ctx, v102);

7984

        let v105 = constructor_x64_and(ctx, I64, v103, v104);

7985

        let v106 = C::gpr_to_reg(ctx, v105);

7986

        let v107 = C::gpr_new(ctx, v95);

7987

        let v108 = &constructor_reg_to_gpr_mem_imm(ctx, v106);

7988

        let v109 = constructor_x64_or(ctx, I64, v107, v108);

7989

        let v110 = C::gpr_to_reg(ctx, v109);

7990

        let v70 = RegMemImm::Imm { simm32: 0x1 };

7991

        let v111 = &C::gpr_mem_imm_new(ctx, &v70);

7992

        let v112 = C::gpr_new(ctx, v110);

7993

        let v113 = &constructor_x64_test(ctx, &OperandSize::Size64, v111, v112);

7994

        let v114 = &constructor_icmp_cond_result(ctx, v113, &CC::NZ);

7995

        // Rule at src/isa/x64/inst.isle line 4451.

7996

        return v114.clone();

7997

7998

    let v29 = C::def_inst(ctx, arg1);

7999

    if let Some(v30) = v29 {

8000

        let v31 = &C::inst_data(ctx, v30);

8001

        if let &InstructionData::UnaryImm {

8002

            opcode: ref v32,

8003

            imm: v33,

8004

        } = v31

8005

8006

            if let &Opcode::Iconst = v32 {

8007

                let v34 = C::u64_from_imm64(ctx, v33);

8008

                if v34 == 0x0 {

8009

                    let v35 = C::value_type(ctx, arg2);

8010

                    let v36 = &C::raw_operand_size_of_type(ctx, v35);

8011

                    let v37 = C::put_in_reg(ctx, arg2);

8012

                    let v38 = C::gpr_new(ctx, v37);

8013

                    let v39 = &C::gpr_to_gpr_mem_imm(ctx, v38);

8014

                    let v40 = &constructor_x64_test(ctx, v36, v39, v38);

8015

                    let v41 = &C::intcc_reverse(ctx, arg0);

8016

                    let v42 = &C::intcc_to_cc(ctx, v41);

8017

                    let v43 = &constructor_icmp_cond_result(ctx, v40, v42);

8018

                    // Rule at src/isa/x64/inst.isle line 4408.

8019

                    return v43.clone();

8020

8021

8022

8023

8024

    let v17 = C::def_inst(ctx, arg2);

8025

    if let Some(v18) = v17 {

8026

        let v19 = &C::inst_data(ctx, v18);

8027

        if let &InstructionData::UnaryImm {

8028

            opcode: ref v20,

8029

            imm: v21,

8030

        } = v19

8031

8032

            if let &Opcode::Iconst = v20 {

8033

                let v22 = C::u64_from_imm64(ctx, v21);

8034

                if v22 == 0x0 {

8035

                    let v4 = &C::raw_operand_size_of_type(ctx, v2);

8036

                    let v23 = C::put_in_reg(ctx, arg1);

8037

                    let v24 = C::gpr_new(ctx, v23);

8038

                    let v25 = &C::gpr_to_gpr_mem_imm(ctx, v24);

8039

                    let v26 = &constructor_x64_test(ctx, v4, v25, v24);

8040

                    let v27 = &C::intcc_to_cc(ctx, arg0);

8041

                    let v28 = &constructor_icmp_cond_result(ctx, v26, v27);

8042

                    // Rule at src/isa/x64/inst.isle line 4403.

8043

                    return v28.clone();

8044

8045

8046

8047

8048

    let v10 = &C::simm32_from_value(ctx, arg1);

8049

    if let Some(v11) = v10 {

8050

        let v4 = &C::raw_operand_size_of_type(ctx, v2);

8051

        let v12 = constructor_put_in_gpr(ctx, arg2);

8052

        let v13 = &constructor_x64_cmp(ctx, v4, v11, v12);

8053

        let v14 = &C::intcc_reverse(ctx, arg0);

8054

        let v15 = &C::intcc_to_cc(ctx, v14);

8055

        let v16 = &constructor_icmp_cond_result(ctx, v13, v15);

8056

        // Rule at src/isa/x64/inst.isle line 4398.

8057

        return v16.clone();

8058

8059

    let v4 = &C::raw_operand_size_of_type(ctx, v2);

8060

    let v5 = &constructor_put_in_gpr_mem_imm(ctx, arg2);

8061

    let v6 = constructor_put_in_gpr(ctx, arg1);

8062

    let v7 = &constructor_x64_cmp(ctx, v4, v5, v6);

8063

    let v8 = &C::intcc_to_cc(ctx, arg0);

8064

    let v9 = &constructor_icmp_cond_result(ctx, v7, v8);

8065

    // Rule at src/isa/x64/inst.isle line 4391.

8066

    return v9.clone();

8067

8068

8069

// Generated as internal constructor for term lower_fcmp_bool.

8070

pub fn constructor_lower_fcmp_bool<C: Context>(ctx: &mut C, arg0: &FcmpCondResult) -> ValueRegs {

8071

    match arg0 {

8072

        &FcmpCondResult::Condition {

8073

            producer: ref v1,

8074

            cc: ref v2,

8075

        } => {

8076

            let v3 = &constructor_x64_setcc(ctx, v2);

8077

            let v4 = constructor_with_flags(ctx, v1, v3);

8078

            // Rule at src/isa/x64/inst.isle line 4486.

8079

            return v4;

8080

8081

        &FcmpCondResult::AndCondition {

8082

            producer: ref v5,

8083

            cc1: ref v6,

8084

            cc2: ref v7,

8085

        } => {

8086

            let v8 = &constructor_x64_setcc(ctx, v6);

8087

            let v9 = &constructor_x64_setcc(ctx, v7);

8088

            let v10 = &constructor_consumes_flags_concat(ctx, v8, v9);

8089

            let v11 = constructor_with_flags(ctx, v5, v10);

8090

            let v13 = constructor_value_regs_get_gpr(ctx, v11, 0x0);

8091

            let v15 = constructor_value_regs_get_gpr(ctx, v11, 0x1);

8092

            let v17 = &C::gpr_to_gpr_mem_imm(ctx, v15);

8093

            let v18 = constructor_x64_and(ctx, I8, v13, v17);

8094

            let v19 = C::gpr_to_reg(ctx, v18);

8095

            let v20 = C::value_reg(ctx, v19);

8096

            // Rule at src/isa/x64/inst.isle line 4489.

8097

            return v20;

8098

8099

        &FcmpCondResult::OrCondition {

8100

            producer: ref v21,

8101

            cc1: ref v22,

8102

            cc2: ref v23,

8103

        } => {

8104

            let v24 = &constructor_x64_setcc(ctx, v22);

8105

            let v25 = &constructor_x64_setcc(ctx, v23);

8106

            let v26 = &constructor_consumes_flags_concat(ctx, v24, v25);

8107

            let v27 = constructor_with_flags(ctx, v21, v26);

8108

            let v28 = constructor_value_regs_get_gpr(ctx, v27, 0x0);

8109

            let v29 = constructor_value_regs_get_gpr(ctx, v27, 0x1);

8110

            let v30 = &C::gpr_to_gpr_mem_imm(ctx, v29);

8111

            let v31 = constructor_x64_or(ctx, I8, v28, v30);

8112

            let v32 = C::gpr_to_reg(ctx, v31);

8113

            let v33 = C::value_reg(ctx, v32);

8114

            // Rule at src/isa/x64/inst.isle line 4498.

8115

            return v33;

8116

8117

        _ => {}

8118

8119

    unreachable!(

8120

        "no rule matched for term {} at {}; should it be partial?",

8121

        "lower_fcmp_bool", "src/isa/x64/inst.isle line 4484"

8122

8123

8124

8125

// Generated as internal constructor for term emit_fcmp.

8126

pub fn constructor_emit_fcmp<C: Context>(

8127

    ctx: &mut C,

8128

    arg0: &FloatCC,

8129

    arg1: Value,

8130

    arg2: Value,

8131

) -> FcmpCondResult {

8132

    match arg0 {

8133

        &FloatCC::Equal => {

8134

            let v2 = C::value_type(ctx, arg1);

8135

            let v3 = C::ty_scalar_float(ctx, v2);

8136

            if let Some(v4) = v3 {

8137

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

8138

                let v9 = FcmpCondResult::AndCondition {

8139

                    producer: v6.clone(),

8140

                    cc1: CC::NP,

8141

                    cc2: CC::Z,

8142

};

8143

                // Rule at src/isa/x64/inst.isle line 4525.

8144

                return v9;

8145

8146

8147

        &FloatCC::GreaterThan => {

8148

            let v2 = C::value_type(ctx, arg1);

8149

            let v3 = C::ty_scalar_float(ctx, v2);

8150

            if let Some(v4) = v3 {

8151

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

8152

                let v18 = FcmpCondResult::Condition {

8153

                    producer: v6.clone(),

8154

                    cc: CC::NBE,

8155

};

8156

                // Rule at src/isa/x64/inst.isle line 4541.

8157

                return v18;

8158

8159

8160

        &FloatCC::GreaterThanOrEqual => {

8161

            let v2 = C::value_type(ctx, arg1);

8162

            let v3 = C::ty_scalar_float(ctx, v2);

8163

            if let Some(v4) = v3 {

8164

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

8165

                let v20 = FcmpCondResult::Condition {

8166

                    producer: v6.clone(),

8167

                    cc: CC::NB,

8168

};

8169

                // Rule at src/isa/x64/inst.isle line 4543.

8170

                return v20;

8171

8172

8173

        &FloatCC::LessThan => {

8174

            let v2 = C::value_type(ctx, arg1);

8175

            let v3 = C::ty_scalar_float(ctx, v2);

8176

            if let Some(v4) = v3 {

8177

                let v25 = &constructor_x64_ucomis(ctx, arg1, arg2);

8178

                let v26 = FcmpCondResult::Condition {

8179

                    producer: v25.clone(),

8180

                    cc: CC::NBE,

8181

};

8182

                // Rule at src/isa/x64/inst.isle line 4553.

8183

                return v26;

8184

8185

8186

        &FloatCC::LessThanOrEqual => {

8187

            let v2 = C::value_type(ctx, arg1);

8188

            let v3 = C::ty_scalar_float(ctx, v2);

8189

            if let Some(v4) = v3 {

8190

                let v25 = &constructor_x64_ucomis(ctx, arg1, arg2);

8191

                let v27 = FcmpCondResult::Condition {

8192

                    producer: v25.clone(),

8193

                    cc: CC::NB,

8194

};

8195

                // Rule at src/isa/x64/inst.isle line 4556.

8196

                return v27;

8197

8198

8199

        &FloatCC::NotEqual => {

8200

            let v2 = C::value_type(ctx, arg1);

8201

            let v3 = C::ty_scalar_float(ctx, v2);

8202

            if let Some(v4) = v3 {

8203

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

8204

                let v12 = FcmpCondResult::OrCondition {

8205

                    producer: v6.clone(),

8206

                    cc1: CC::P,

8207

                    cc2: CC::NZ,

8208

};

8209

                // Rule at src/isa/x64/inst.isle line 4528.

8210

                return v12;

8211

8212

8213

        &FloatCC::Ordered => {

8214

            let v2 = C::value_type(ctx, arg1);

8215

            let v3 = C::ty_scalar_float(ctx, v2);

8216

            if let Some(v4) = v3 {

8217

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

8218

                let v13 = FcmpCondResult::Condition {

8219

                    producer: v6.clone(),

8220

                    cc: CC::NP,

8221

};

8222

                // Rule at src/isa/x64/inst.isle line 4533.

8223

                return v13;

8224

8225

8226

        &FloatCC::OrderedNotEqual => {

8227

            let v2 = C::value_type(ctx, arg1);

8228

            let v3 = C::ty_scalar_float(ctx, v2);

8229

            if let Some(v4) = v3 {

8230

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

8231

                let v15 = FcmpCondResult::Condition {

8232

                    producer: v6.clone(),

8233

                    cc: CC::NZ,

8234

};

8235

                // Rule at src/isa/x64/inst.isle line 4537.

8236

                return v15;

8237

8238

8239

        &FloatCC::Unordered => {

8240

            let v2 = C::value_type(ctx, arg1);

8241

            let v3 = C::ty_scalar_float(ctx, v2);

8242

            if let Some(v4) = v3 {

8243

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

8244

                let v14 = FcmpCondResult::Condition {

8245

                    producer: v6.clone(),

8246

                    cc: CC::P,

8247

};

8248

                // Rule at src/isa/x64/inst.isle line 4535.

8249

                return v14;

8250

8251

8252

        &FloatCC::UnorderedOrEqual => {

8253

            let v2 = C::value_type(ctx, arg1);

8254

            let v3 = C::ty_scalar_float(ctx, v2);

8255

            if let Some(v4) = v3 {

8256

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

8257

                let v16 = FcmpCondResult::Condition {

8258

                    producer: v6.clone(),

8259

                    cc: CC::Z,

8260

};

8261

                // Rule at src/isa/x64/inst.isle line 4539.

8262

                return v16;

8263

8264

8265

        &FloatCC::UnorderedOrGreaterThan => {

8266

            let v2 = C::value_type(ctx, arg1);

8267

            let v3 = C::ty_scalar_float(ctx, v2);

8268

            if let Some(v4) = v3 {

8269

                let v25 = &constructor_x64_ucomis(ctx, arg1, arg2);

8270

                let v28 = FcmpCondResult::Condition {

8271

                    producer: v25.clone(),

8272

                    cc: CC::B,

8273

};

8274

                // Rule at src/isa/x64/inst.isle line 4559.

8275

                return v28;

8276

8277

8278

        &FloatCC::UnorderedOrGreaterThanOrEqual => {

8279

            let v2 = C::value_type(ctx, arg1);

8280

            let v3 = C::ty_scalar_float(ctx, v2);

8281

            if let Some(v4) = v3 {

8282

                let v25 = &constructor_x64_ucomis(ctx, arg1, arg2);

8283

                let v29 = FcmpCondResult::Condition {

8284

                    producer: v25.clone(),

8285

                    cc: CC::BE,

8286

};

8287

                // Rule at src/isa/x64/inst.isle line 4562.

8288

                return v29;

8289

8290

8291

        &FloatCC::UnorderedOrLessThan => {

8292

            let v2 = C::value_type(ctx, arg1);

8293

            let v3 = C::ty_scalar_float(ctx, v2);

8294

            if let Some(v4) = v3 {

8295

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

8296

                let v22 = FcmpCondResult::Condition {

8297

                    producer: v6.clone(),

8298

                    cc: CC::B,

8299

};

8300

                // Rule at src/isa/x64/inst.isle line 4545.

8301

                return v22;

8302

8303

8304

        &FloatCC::UnorderedOrLessThanOrEqual => {

8305

            let v2 = C::value_type(ctx, arg1);

8306

            let v3 = C::ty_scalar_float(ctx, v2);

8307

            if let Some(v4) = v3 {

8308

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

8309

                let v24 = FcmpCondResult::Condition {

8310

                    producer: v6.clone(),

8311

                    cc: CC::BE,

8312

};

8313

                // Rule at src/isa/x64/inst.isle line 4547.

8314

                return v24;

8315

8316

8317

        _ => {}

8318

8319

    unreachable!(

8320

        "no rule matched for term {} at {}; should it be partial?",

8321

        "emit_fcmp", "src/isa/x64/inst.isle line 4523"

8322

8323

8324

8325

// Generated as internal constructor for term x64_mfence.

8326

pub fn constructor_x64_mfence<C: Context>(ctx: &mut C) -> SideEffectNoResult {

8327

    let v1 = MInst::Fence {

8328

        kind: FenceKind::MFence,

8329

};

8330

    let v2 = SideEffectNoResult::Inst { inst: v1 };

8331

    // Rule at src/isa/x64/inst.isle line 4575.

8332

    return v2;

8333

8334

8335

// Generated as internal constructor for term x64_cmpxchg.

8336

pub fn constructor_x64_cmpxchg<C: Context>(

8337

    ctx: &mut C,

8338

    arg0: Type,

8339

    arg1: Gpr,

8340

    arg2: Gpr,

8341

    arg3: &SyntheticAmode,

8342

) -> Gpr {

8343

    let v4 = C::temp_writable_gpr(ctx);

8344

    let v5 = C::gpr_to_reg(ctx, arg2);

8345

    let v6 = C::gpr_to_reg(ctx, arg1);

8346

    let v7 = C::writable_gpr_to_reg(ctx, v4);

8347

    let v8 = MInst::LockCmpxchg {

8348

        ty: arg0,

8349

        replacement: v5,

8350

        expected: v6,

8351

        mem: arg3.clone(),

8352

        dst_old: v7,

8353

};

8354

    let v9 = C::emit(ctx, &v8);

8355

    let v10 = C::writable_gpr_to_gpr(ctx, v4);

8356

    // Rule at src/isa/x64/inst.isle line 4579.

8357

    return v10;

8358

8359

8360

// Generated as internal constructor for term x64_atomic_rmw_seq.

8361

pub fn constructor_x64_atomic_rmw_seq<C: Context>(

8362

    ctx: &mut C,

8363

    arg0: Type,

8364

    arg1: &MachAtomicRmwOp,

8365

    arg2: &SyntheticAmode,

8366

    arg3: Gpr,

8367

) -> Gpr {

8368

    let v4 = C::temp_writable_gpr(ctx);

8369

    let v5 = C::temp_writable_gpr(ctx);

8370

    let v6 = C::gpr_to_reg(ctx, arg3);

8371

    let v7 = C::writable_gpr_to_reg(ctx, v5);

8372

    let v8 = C::writable_gpr_to_reg(ctx, v4);

8373

    let v9 = MInst::AtomicRmwSeq {

8374

        ty: arg0,

8375

        op: arg1.clone(),

8376

        mem: arg2.clone(),

8377

        operand: v6,

8378

        temp: v7,

8379

        dst_old: v8,

8380

};

8381

    let v10 = C::emit(ctx, &v9);

8382

    let v11 = C::writable_gpr_to_gpr(ctx, v4);

8383

    // Rule at src/isa/x64/inst.isle line 4585.

8384

    return v11;

8385

8386

8387

// Generated as internal constructor for term bitcast_xmm_to_gpr.

8388

pub fn constructor_bitcast_xmm_to_gpr<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm) -> Gpr {

8389

    match arg0 {

8390

        F32 => {

8391

            let v2 = constructor_x64_movd_to_gpr(ctx, arg1);

8392

            // Rule at src/isa/x64/inst.isle line 4600.

8393

            return v2;

8394

8395

        F64 => {

8396

            let v3 = constructor_x64_movq_to_gpr(ctx, arg1);

8397

            // Rule at src/isa/x64/inst.isle line 4602.

8398

            return v3;

8399

8400

        _ => {}

8401

8402

    unreachable!(

8403

        "no rule matched for term {} at {}; should it be partial?",

8404

        "bitcast_xmm_to_gpr", "src/isa/x64/inst.isle line 4599"

8405

8406

8407

8408

// Generated as internal constructor for term bitcast_gpr_to_xmm.

8409

pub fn constructor_bitcast_gpr_to_xmm<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Xmm {

8410

    match arg0 {

8411

        I32 => {

8412

            let v2 = &C::gpr_to_gpr_mem(ctx, arg1);

8413

            let v3 = constructor_x64_movd_to_xmm(ctx, v2);

8414

            // Rule at src/isa/x64/inst.isle line 4606.

8415

            return v3;

8416

8417

        I64 => {

8418

            let v2 = &C::gpr_to_gpr_mem(ctx, arg1);

8419

            let v4 = constructor_x64_movq_to_xmm(ctx, v2);

8420

            // Rule at src/isa/x64/inst.isle line 4608.

8421

            return v4;

8422

8423

        _ => {}

8424

8425

    unreachable!(

8426

        "no rule matched for term {} at {}; should it be partial?",

8427

        "bitcast_gpr_to_xmm", "src/isa/x64/inst.isle line 4605"

8428

8429

8430

8431

// Generated as internal constructor for term stack_addr_impl.

8432

pub fn constructor_stack_addr_impl<C: Context>(

8433

    ctx: &mut C,

8434

    arg0: StackSlot,

8435

    arg1: Offset32,

8436

) -> Gpr {

8437

    let v2 = C::temp_writable_gpr(ctx);

8438

    let v3 = C::writable_gpr_to_reg(ctx, v2);

8439

    let v4 = &C::abi_stackslot_addr(ctx, v3, arg0, arg1);

8440

    let v5 = C::emit(ctx, v4);

8441

    let v6 = C::writable_gpr_to_gpr(ctx, v2);

8442

    // Rule at src/isa/x64/inst.isle line 4614.

8443

    return v6;

8444

8445

8446

// Generated as internal constructor for term x64_checked_srem_seq.

8447

pub fn constructor_x64_checked_srem_seq<C: Context>(

8448

    ctx: &mut C,

8449

    arg0: &OperandSize,

8450

    arg1: Gpr,

8451

    arg2: Gpr,

8452

    arg3: Gpr,

8453

) -> ValueRegs {

8454

    let v4 = C::temp_writable_gpr(ctx);

8455

    let v5 = C::temp_writable_gpr(ctx);

8456

    let v6 = MInst::CheckedSRemSeq {

8457

        size: arg0.clone(),

8458

        dividend_lo: arg1,

8459

        dividend_hi: arg2,

8460

        divisor: arg3,

8461

        dst_quotient: v4,

8462

        dst_remainder: v5,

8463

};

8464

    let v7 = C::emit(ctx, &v6);

8465

    let v8 = constructor_writable_gpr_to_r_reg(ctx, v4);

8466

    let v9 = constructor_writable_gpr_to_r_reg(ctx, v5);

8467

    let v10 = C::value_regs(ctx, v8, v9);

8468

    // Rule at src/isa/x64/inst.isle line 4623.

8469

    return v10;

8470

8471

8472

// Generated as internal constructor for term x64_checked_srem_seq8.

8473

pub fn constructor_x64_checked_srem_seq8<C: Context>(ctx: &mut C, arg0: Gpr, arg1: Gpr) -> Gpr {

8474

    let v2 = C::temp_writable_gpr(ctx);

8475

    let v3 = MInst::CheckedSRemSeq8 {

8476

        dividend: arg0,

8477

        divisor: arg1,

8478

        dst: v2,

8479

};

8480

    let v4 = C::emit(ctx, &v3);

8481

    let v5 = C::writable_gpr_to_gpr(ctx, v2);

8482

    // Rule at src/isa/x64/inst.isle line 4630.

8483

    return v5;

8484

8485

8486

// Generated as internal constructor for term x64_div8.

8487

pub fn constructor_x64_div8<C: Context>(

8488

    ctx: &mut C,

8489

    arg0: Gpr,

8490

    arg1: &GprMem,

8491

    arg2: &DivSignedness,

8492

    arg3: &TrapCode,

8493

) -> Gpr {

8494

    let v4 = C::temp_writable_gpr(ctx);

8495

    let v5 = MInst::Div8 {

8496

        sign: arg2.clone(),

8497

        trap: arg3.clone(),

8498

        divisor: arg1.clone(),

8499

        dividend: arg0,

8500

        dst: v4,

8501

};

8502

    let v6 = C::emit(ctx, &v5);

8503

    let v7 = C::writable_gpr_to_gpr(ctx, v4);

8504

    // Rule at src/isa/x64/inst.isle line 4637.

8505

    return v7;

8506

8507

8508

// Generated as internal constructor for term x64_div.

8509

pub fn constructor_x64_div<C: Context>(

8510

    ctx: &mut C,

8511

    arg0: Gpr,

8512

    arg1: Gpr,

8513

    arg2: &GprMem,

8514

    arg3: &OperandSize,

8515

    arg4: &DivSignedness,

8516

    arg5: &TrapCode,

8517

) -> ValueRegs {

8518

    let v6 = C::temp_writable_gpr(ctx);

8519

    let v7 = C::temp_writable_gpr(ctx);

8520

    let v8 = MInst::Div {

8521

        size: arg3.clone(),

8522

        sign: arg4.clone(),

8523

        trap: arg5.clone(),

8524

        divisor: arg2.clone(),

8525

        dividend_lo: arg0,

8526

        dividend_hi: arg1,

8527

        dst_quotient: v6,

8528

        dst_remainder: v7,

8529

};

8530

    let v9 = C::emit(ctx, &v8);

8531

    let v10 = constructor_writable_gpr_to_r_reg(ctx, v6);

8532

    let v11 = constructor_writable_gpr_to_r_reg(ctx, v7);

8533

    let v12 = C::value_regs(ctx, v10, v11);

8534

    // Rule at src/isa/x64/inst.isle line 4647.

8535

    return v12;

8536

8537

8538

// Generated as internal constructor for term x64_div_quotient.

8539

pub fn constructor_x64_div_quotient<C: Context>(

8540

    ctx: &mut C,

8541

    arg0: Gpr,

8542

    arg1: Gpr,

8543

    arg2: &GprMem,

8544

    arg3: &OperandSize,

8545

    arg4: &DivSignedness,

8546

    arg5: &TrapCode,

8547

) -> ValueRegs {

8548

    let v6 = constructor_x64_div(ctx, arg0, arg1, arg2, arg3, arg4, arg5);

8549

    let v8 = C::value_regs_get(ctx, v6, 0x0);

8550

    let v9 = C::value_reg(ctx, v8);

8551

    // Rule at src/isa/x64/inst.isle line 4655.

8552

    return v9;

8553

8554

8555

// Generated as internal constructor for term x64_div_remainder.

8556

pub fn constructor_x64_div_remainder<C: Context>(

8557

    ctx: &mut C,

8558

    arg0: Gpr,

8559

    arg1: Gpr,

8560

    arg2: &GprMem,

8561

    arg3: &OperandSize,

8562

    arg4: &DivSignedness,

8563

    arg5: &TrapCode,

8564

) -> ValueRegs {

8565

    let v6 = constructor_x64_div(ctx, arg0, arg1, arg2, arg3, arg4, arg5);

8566

    let v8 = C::value_regs_get(ctx, v6, 0x1);

8567

    let v9 = C::value_reg(ctx, v8);

8568

    // Rule at src/isa/x64/inst.isle line 4660.

8569

    return v9;

8570

8571

8572

// Generated as internal constructor for term x64_sign_extend_data.

8573

pub fn constructor_x64_sign_extend_data<C: Context>(

8574

    ctx: &mut C,

8575

    arg0: Gpr,

8576

    arg1: &OperandSize,

8577

) -> Gpr {

8578

    let v2 = C::temp_writable_gpr(ctx);

8579

    let v3 = MInst::SignExtendData {

8580

        size: arg1.clone(),

8581

        src: arg0,

8582

        dst: v2,

8583

};

8584

    let v4 = C::emit(ctx, &v3);

8585

    let v5 = C::writable_gpr_to_gpr(ctx, v2);

8586

    // Rule at src/isa/x64/inst.isle line 4665.

8587

    return v5;

8588

8589

8590

// Generated as internal constructor for term read_pinned_gpr.

8591

pub fn constructor_read_pinned_gpr<C: Context>(ctx: &mut C) -> Gpr {

8592

    let v0 = C::preg_pinned(ctx);

8593

    let v1 = constructor_mov_from_preg(ctx, v0);

8594

    let v2 = C::gpr_new(ctx, v1);

8595

    // Rule at src/isa/x64/inst.isle line 4673.

8596

    return v2;

8597

8598

8599

// Generated as internal constructor for term write_pinned_gpr.

8600

pub fn constructor_write_pinned_gpr<C: Context>(ctx: &mut C, arg0: Gpr) -> SideEffectNoResult {

8601

    let v1 = C::preg_pinned(ctx);

8602

    let v2 = &constructor_mov_to_preg(ctx, v1, arg0);

8603

    // Rule at src/isa/x64/inst.isle line 4677.

8604

    return v2.clone();

8605

8606

8607

// Generated as internal constructor for term elf_tls_get_addr.

8608

pub fn constructor_elf_tls_get_addr<C: Context>(ctx: &mut C, arg0: ExternalName) -> Gpr {

8609

    let v1 = C::temp_writable_gpr(ctx);

8610

    let v2 = MInst::ElfTlsGetAddr {

8611

        symbol: arg0,

8612

        dst: v1,

8613

};

8614

    let v3 = C::emit(ctx, &v2);

8615

    let v4 = C::writable_gpr_to_gpr(ctx, v1);

8616

    // Rule at src/isa/x64/inst.isle line 4725.

8617

    return v4;

8618

8619

8620

// Generated as internal constructor for term macho_tls_get_addr.

8621

pub fn constructor_macho_tls_get_addr<C: Context>(ctx: &mut C, arg0: ExternalName) -> Gpr {

8622

    let v1 = C::temp_writable_gpr(ctx);

8623

    let v2 = MInst::MachOTlsGetAddr {

8624

        symbol: arg0,

8625

        dst: v1,

8626

};

8627

    let v3 = C::emit(ctx, &v2);

8628

    let v4 = C::writable_gpr_to_gpr(ctx, v1);

8629

    // Rule at src/isa/x64/inst.isle line 4732.

8630

    return v4;

8631

8632

8633

// Generated as internal constructor for term coff_tls_get_addr.

8634

pub fn constructor_coff_tls_get_addr<C: Context>(ctx: &mut C, arg0: ExternalName) -> Gpr {

8635

    let v1 = C::temp_writable_gpr(ctx);

8636

    let v2 = C::temp_writable_gpr(ctx);

8637

    let v3 = MInst::CoffTlsGetAddr {

8638

        symbol: arg0,

8639

        dst: v1,

8640

        tmp: v2,

8641

};

8642

    let v4 = C::emit(ctx, &v3);

8643

    let v5 = C::writable_gpr_to_gpr(ctx, v1);

8644

    // Rule at src/isa/x64/inst.isle line 4739.

8645

    return v5;

8646

8647

8648

// Generated as internal constructor for term reg_to_xmm_mem.

8649

pub fn constructor_reg_to_xmm_mem<C: Context>(ctx: &mut C, arg0: Reg) -> XmmMem {

8650

    let v1 = C::xmm_new(ctx, arg0);

8651

    let v2 = &C::xmm_to_xmm_mem(ctx, v1);

8652

    // Rule at src/isa/x64/inst.isle line 4837.

8653

    return v2.clone();

8654

8655

8656

// Generated as internal constructor for term xmm_to_reg_mem.

8657

pub fn constructor_xmm_to_reg_mem<C: Context>(ctx: &mut C, arg0: Reg) -> XmmMem {

8658

    let v1 = C::xmm_new(ctx, arg0);

8659

    let v2 = C::xmm_to_reg(ctx, v1);

8660

    let v3 = RegMem::Reg { reg: v2 };

8661

    let v4 = &C::reg_mem_to_xmm_mem(ctx, &v3);

8662

    // Rule at src/isa/x64/inst.isle line 4840.

8663

    return v4.clone();

8664

8665

8666

// Generated as internal constructor for term writable_gpr_to_r_reg.

8667

pub fn constructor_writable_gpr_to_r_reg<C: Context>(ctx: &mut C, arg0: WritableGpr) -> Reg {

8668

    let v1 = C::writable_gpr_to_reg(ctx, arg0);

8669

    let v2 = C::writable_reg_to_reg(ctx, v1);

8670

    // Rule at src/isa/x64/inst.isle line 4844.

8671

    return v2;

8672

8673

8674

// Generated as internal constructor for term writable_gpr_to_gpr_mem.

8675

pub fn constructor_writable_gpr_to_gpr_mem<C: Context>(ctx: &mut C, arg0: WritableGpr) -> GprMem {

8676

    let v1 = C::writable_gpr_to_gpr(ctx, arg0);

8677

    let v2 = &C::gpr_to_gpr_mem(ctx, v1);

8678

    // Rule at src/isa/x64/inst.isle line 4847.

8679

    return v2.clone();

8680

8681

8682

// Generated as internal constructor for term writable_gpr_to_value_regs.

8683

pub fn constructor_writable_gpr_to_value_regs<C: Context>(

8684

    ctx: &mut C,

8685

    arg0: WritableGpr,

8686

) -> ValueRegs {

8687

    let v1 = constructor_writable_gpr_to_r_reg(ctx, arg0);

8688

    let v2 = C::value_reg(ctx, v1);

8689

    // Rule at src/isa/x64/inst.isle line 4850.

8690

    return v2;

8691

8692

8693

// Generated as internal constructor for term writable_xmm_to_r_reg.

8694

pub fn constructor_writable_xmm_to_r_reg<C: Context>(ctx: &mut C, arg0: WritableXmm) -> Reg {

8695

    let v1 = C::writable_xmm_to_reg(ctx, arg0);

8696

    let v2 = C::writable_reg_to_reg(ctx, v1);

8697

    // Rule at src/isa/x64/inst.isle line 4853.

8698

    return v2;

8699

8700

8701

// Generated as internal constructor for term writable_xmm_to_xmm_mem.

8702

pub fn constructor_writable_xmm_to_xmm_mem<C: Context>(ctx: &mut C, arg0: WritableXmm) -> XmmMem {

8703

    let v1 = C::writable_xmm_to_xmm(ctx, arg0);

8704

    let v2 = &C::xmm_to_xmm_mem(ctx, v1);

8705

    // Rule at src/isa/x64/inst.isle line 4856.

8706

    return v2.clone();

8707

8708

8709

// Generated as internal constructor for term writable_xmm_to_value_regs.

8710

pub fn constructor_writable_xmm_to_value_regs<C: Context>(

8711

    ctx: &mut C,

8712

    arg0: WritableXmm,

8713

) -> ValueRegs {

8714

    let v1 = constructor_writable_xmm_to_r_reg(ctx, arg0);

8715

    let v2 = C::value_reg(ctx, v1);

8716

    // Rule at src/isa/x64/inst.isle line 4859.

8717

    return v2;

8718

8719

8720

// Generated as internal constructor for term synthetic_amode_to_gpr_mem.

8721

pub fn constructor_synthetic_amode_to_gpr_mem<C: Context>(

8722

    ctx: &mut C,

8723

    arg0: &SyntheticAmode,

8724

) -> GprMem {

8725

    let v1 = &C::synthetic_amode_to_reg_mem(ctx, arg0);

8726

    let v2 = &C::reg_mem_to_gpr_mem(ctx, v1);

8727

    // Rule at src/isa/x64/inst.isle line 4866.

8728

    return v2.clone();

8729

8730

8731

// Generated as internal constructor for term amode_to_gpr_mem.

8732

pub fn constructor_amode_to_gpr_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> GprMem {

8733

    let v1 = &C::amode_to_synthetic_amode(ctx, arg0);

8734

    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, v1);

8735

    // Rule at src/isa/x64/inst.isle line 4864.

8736

    return v2.clone();

8737

8738

8739

// Generated as internal constructor for term amode_to_xmm_mem.

8740

pub fn constructor_amode_to_xmm_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> XmmMem {

8741

    let v1 = &C::amode_to_synthetic_amode(ctx, arg0);

8742

    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, v1);

8743

    // Rule at src/isa/x64/inst.isle line 4869.

8744

    return v2.clone();

8745

8746

8747

// Generated as internal constructor for term synthetic_amode_to_xmm_mem.

8748

pub fn constructor_synthetic_amode_to_xmm_mem<C: Context>(

8749

    ctx: &mut C,

8750

    arg0: &SyntheticAmode,

8751

) -> XmmMem {

8752

    let v1 = &C::synthetic_amode_to_reg_mem(ctx, arg0);

8753

    let v2 = &C::reg_mem_to_xmm_mem(ctx, v1);

8754

    // Rule at src/isa/x64/inst.isle line 4872.

8755

    return v2.clone();

8756

8757

8758

// Generated as internal constructor for term const_to_xmm_mem.

8759

pub fn constructor_const_to_xmm_mem<C: Context>(ctx: &mut C, arg0: VCodeConstant) -> XmmMem {

8760

    let v1 = &C::const_to_synthetic_amode(ctx, arg0);

8761

    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, v1);

8762

    // Rule at src/isa/x64/inst.isle line 4877.

8763

    return v2.clone();

8764

8765

8766

// Generated as internal constructor for term xmm_to_xmm_mem_aligned.

8767

pub fn constructor_xmm_to_xmm_mem_aligned<C: Context>(ctx: &mut C, arg0: Xmm) -> XmmMemAligned {

8768

    let v1 = &C::xmm_to_xmm_mem(ctx, arg0);

8769

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);

8770

    // Rule at src/isa/x64/inst.isle line 4880.

8771

    return v2.clone();

8772

8773

8774

// Generated as internal constructor for term amode_to_xmm_mem_aligned.

8775

pub fn constructor_amode_to_xmm_mem_aligned<C: Context>(

8776

    ctx: &mut C,

8777

    arg0: &Amode,

8778

) -> XmmMemAligned {

8779

    let v1 = &constructor_amode_to_xmm_mem(ctx, arg0);

8780

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);

8781

    // Rule at src/isa/x64/inst.isle line 4882.

8782

    return v2.clone();

8783

8784

8785

// Generated as internal constructor for term synthetic_amode_to_xmm_mem_aligned.

8786

pub fn constructor_synthetic_amode_to_xmm_mem_aligned<C: Context>(

8787

    ctx: &mut C,

8788

    arg0: &SyntheticAmode,

8789

) -> XmmMemAligned {

8790

    let v1 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

8791

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);

8792

    // Rule at src/isa/x64/inst.isle line 4884.

8793

    return v2.clone();

8794

8795

8796

// Generated as internal constructor for term put_in_xmm_mem_aligned.

8797

pub fn constructor_put_in_xmm_mem_aligned<C: Context>(ctx: &mut C, arg0: Value) -> XmmMemAligned {

8798

    let v1 = &C::put_in_xmm_mem(ctx, arg0);

8799

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);

8800

    // Rule at src/isa/x64/inst.isle line 4886.

8801

    return v2.clone();

8802

8803

8804

// Generated as internal constructor for term mov_from_preg.

8805

pub fn constructor_mov_from_preg<C: Context>(ctx: &mut C, arg0: PReg) -> Reg {

8806

    let v1 = C::temp_writable_gpr(ctx);

8807

    let v2 = MInst::MovFromPReg { src: arg0, dst: v1 };

8808

    let v3 = C::emit(ctx, &v2);

8809

    let v4 = constructor_writable_gpr_to_r_reg(ctx, v1);

8810

    // Rule at src/isa/x64/inst.isle line 4890.

8811

    return v4;

8812

8813

8814

// Generated as internal constructor for term mov_to_preg.

8815

pub fn constructor_mov_to_preg<C: Context>(

8816

    ctx: &mut C,

8817

    arg0: PReg,

8818

    arg1: Gpr,

8819

) -> SideEffectNoResult {

8820

    let v2 = MInst::MovToPReg {

8821

        src: arg1,

8822

        dst: arg0,

8823

};

8824

    let v3 = SideEffectNoResult::Inst { inst: v2 };

8825

    // Rule at src/isa/x64/inst.isle line 4896.

8826

    return v3;

8827

8828

8829

// Generated as internal constructor for term x64_rbp.

8830

pub fn constructor_x64_rbp<C: Context>(ctx: &mut C) -> Reg {

8831

    let v0 = C::preg_rbp(ctx);

8832

    let v1 = constructor_mov_from_preg(ctx, v0);

8833

    // Rule at src/isa/x64/inst.isle line 4909.

8834

    return v1;

8835

8836

8837

// Generated as internal constructor for term x64_rsp.

8838

pub fn constructor_x64_rsp<C: Context>(ctx: &mut C) -> Reg {

8839

    let v0 = C::preg_rsp(ctx);

8840

    let v1 = constructor_mov_from_preg(ctx, v0);

8841

    // Rule at src/isa/x64/inst.isle line 4913.

8842

    return v1;

8843

8844

8845

// Generated as internal constructor for term lower.

8846

pub fn constructor_lower<C: Context>(ctx: &mut C, arg0: Inst) -> Option<InstOutput> {

8847

    let v6 = &C::inst_data(ctx, arg0);

8848

    match v6 {

8849

        &InstructionData::AtomicCas {

8850

            opcode: ref v1488,

8851

            args: ref v1489,

8852

            flags: v1490,

8853

        } => {

8854

            if let &Opcode::AtomicCas = v1488 {

8855

                let v1 = C::first_result(ctx, arg0);

8856

                if let Some(v2) = v1 {

8857

                    let v3 = C::value_type(ctx, v2);

8858

                    let v4 = C::fits_in_64(ctx, v3);

8859

                    if let Some(v5) = v4 {

8860

                        let v1463 = C::ty_int(ctx, v3);

8861

                        if let Some(v1464) = v1463 {

8862

                            let v1491 = C::unpack_value_array_3(ctx, v1489);

8863

                            let v1495 = constructor_put_in_gpr(ctx, v1491.1);

8864

                            let v1496 = constructor_put_in_gpr(ctx, v1491.2);

8865

                            let v1497 = C::zero_offset(ctx);

8866

                            let v1498 = &constructor_to_amode(ctx, v1490, v1491.0, v1497);

8867

                            let v1499 = &C::amode_to_synthetic_amode(ctx, v1498);

8868

                            let v1500 = constructor_x64_cmpxchg(ctx, v5, v1495, v1496, v1499);

8869

                            let v1501 = constructor_output_gpr(ctx, v1500);

8870

                            // Rule at src/isa/x64/lower.isle line 2749.

8871

                            return Some(v1501);

8872

8873

8874

8875

8876

8877

        &InstructionData::AtomicRmw {

8878

            opcode: ref v1502,

8879

            args: ref v1503,

8880

            flags: v1504,

8881

            op: ref v1505,

8882

        } => {

8883

            if let &Opcode::AtomicRmw = v1502 {

8884

                let v1 = C::first_result(ctx, arg0);

8885

                if let Some(v2) = v1 {

8886

                    let v3 = C::value_type(ctx, v2);

8887

                    let v4 = C::fits_in_64(ctx, v3);

8888

                    if let Some(v5) = v4 {

8889

                        let v1463 = C::ty_int(ctx, v3);

8890

                        if let Some(v1464) = v1463 {

8891

                            let v1509 = &C::atomic_rmw_op_to_mach_atomic_rmw_op(ctx, v1505);

8892

                            let v1465 = C::zero_offset(ctx);

8893

                            let v1506 = C::unpack_value_array_2(ctx, v1503);

8894

                            let v1510 = &constructor_to_amode(ctx, v1504, v1506.0, v1465);

8895

                            let v1511 = &C::amode_to_synthetic_amode(ctx, v1510);

8896

                            let v1512 = constructor_put_in_gpr(ctx, v1506.1);

8897

                            let v1513 =

8898

                                constructor_x64_atomic_rmw_seq(ctx, v5, v1509, v1511, v1512);

8899

                            let v1514 = constructor_output_gpr(ctx, v1513);

8900

                            // Rule at src/isa/x64/lower.isle line 2765.

8901

                            return Some(v1514);

8902

8903

8904

8905

8906

8907

        &InstructionData::Binary {

8908

            opcode: ref v36,

8909

            args: ref v37,

8910

        } => {

8911

            match v36 {

8912

                &Opcode::Swizzle => {

8913

                    let v38 = C::unpack_value_array_2(ctx, v37);

8914

                    let v1013 = constructor_put_in_xmm(ctx, v38.1);

8915

                    let v2072 = C::swizzle_zero_mask(ctx);

8916

                    let v2073 = &constructor_const_to_xmm_mem(ctx, v2072);

8917

                    let v2074 = constructor_x64_paddusb(ctx, v1013, v2073);

8918

                    let v2075 = constructor_put_in_xmm(ctx, v38.0);

8919

                    let v2076 = &C::xmm_to_xmm_mem(ctx, v2074);

8920

                    let v2077 = constructor_x64_pshufb(ctx, v2075, v2076);

8921

                    let v2078 = constructor_output_xmm(ctx, v2077);

8922

                    // Rule at src/isa/x64/lower.isle line 3702.

8923

                    return Some(v2078);

8924

8925

                &Opcode::X86Pshufb => {

8926

                    let v38 = C::unpack_value_array_2(ctx, v37);

8927

                    let v68 = constructor_put_in_xmm(ctx, v38.0);

8928

                    let v69 = &C::put_in_xmm_mem(ctx, v38.1);

8929

                    let v2079 = constructor_x64_pshufb(ctx, v68, v69);

8930

                    let v2080 = constructor_output_xmm(ctx, v2079);

8931

                    // Rule at src/isa/x64/lower.isle line 3708.

8932

                    return Some(v2080);

8933

8934

                &Opcode::Smin => {

8935

                    let v1 = C::first_result(ctx, arg0);

8936

                    if let Some(v2) = v1 {

8937

                        let v3 = C::value_type(ctx, v2);

8938

                        match v3 {

8939

                            I8X16 => {

8940

                                let v38 = C::unpack_value_array_2(ctx, v37);

8941

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

8942

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

8943

                                let v600 = constructor_x64_pminsb(ctx, v68, v69);

8944

                                let v601 = constructor_output_xmm(ctx, v600);

8945

                                // Rule at src/isa/x64/lower.isle line 1332.

8946

                                return Some(v601);

8947

8948

                            I16X8 => {

8949

                                let v38 = C::unpack_value_array_2(ctx, v37);

8950

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

8951

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

8952

                                let v602 = constructor_x64_pminsw(ctx, v68, v69);

8953

                                let v603 = constructor_output_xmm(ctx, v602);

8954

                                // Rule at src/isa/x64/lower.isle line 1335.

8955

                                return Some(v603);

8956

8957

                            I32X4 => {

8958

                                let v38 = C::unpack_value_array_2(ctx, v37);

8959

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

8960

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

8961

                                let v604 = constructor_x64_pminsd(ctx, v68, v69);

8962

                                let v605 = constructor_output_xmm(ctx, v604);

8963

                                // Rule at src/isa/x64/lower.isle line 1338.

8964

                                return Some(v605);

8965

8966

                            _ => {}

8967

8968

                        let v4 = C::fits_in_64(ctx, v3);

8969

                        if let Some(v5) = v4 {

8970

                            let v38 = C::unpack_value_array_2(ctx, v37);

8971

                            let v589 = constructor_cmp_and_choose(ctx, v5, &CC::L, v38.0, v38.1);

8972

                            let v590 = C::output(ctx, v589);

8973

                            // Rule at src/isa/x64/lower.isle line 1313.

8974

                            return Some(v590);

8975

8976

8977

8978

                &Opcode::Umin => {

8979

                    let v1 = C::first_result(ctx, arg0);

8980

                    if let Some(v2) = v1 {

8981

                        let v3 = C::value_type(ctx, v2);

8982

                        match v3 {

8983

                            I8X16 => {

8984

                                let v38 = C::unpack_value_array_2(ctx, v37);

8985

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

8986

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

8987

                                let v612 = constructor_x64_pminub(ctx, v68, v69);

8988

                                let v613 = constructor_output_xmm(ctx, v612);

8989

                                // Rule at src/isa/x64/lower.isle line 1354.

8990

                                return Some(v613);

8991

8992

                            I16X8 => {

8993

                                let v38 = C::unpack_value_array_2(ctx, v37);

8994

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

8995

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

8996

                                let v614 = constructor_x64_pminuw(ctx, v68, v69);

8997

                                let v615 = constructor_output_xmm(ctx, v614);

8998

                                // Rule at src/isa/x64/lower.isle line 1357.

8999

                                return Some(v615);

9000

9001

                            I32X4 => {

9002

                                let v38 = C::unpack_value_array_2(ctx, v37);

9003

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

9004

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9005

                                let v616 = constructor_x64_pminud(ctx, v68, v69);

9006

                                let v617 = constructor_output_xmm(ctx, v616);

9007

                                // Rule at src/isa/x64/lower.isle line 1360.

9008

                                return Some(v617);

9009

9010

                            _ => {}

9011

9012

                        let v4 = C::fits_in_64(ctx, v3);

9013

                        if let Some(v5) = v4 {

9014

                            let v38 = C::unpack_value_array_2(ctx, v37);

9015

                            let v583 = constructor_cmp_and_choose(ctx, v5, &CC::B, v38.0, v38.1);

9016

                            let v584 = C::output(ctx, v583);

9017

                            // Rule at src/isa/x64/lower.isle line 1307.

9018

                            return Some(v584);

9019

9020

9021

9022

                &Opcode::Smax => {

9023

                    let v1 = C::first_result(ctx, arg0);

9024

                    if let Some(v2) = v1 {

9025

                        let v3 = C::value_type(ctx, v2);

9026

                        match v3 {

9027

                            I8X16 => {

9028

                                let v38 = C::unpack_value_array_2(ctx, v37);

9029

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

9030

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9031

                                let v594 = constructor_x64_pmaxsb(ctx, v68, v69);

9032

                                let v595 = constructor_output_xmm(ctx, v594);

9033

                                // Rule at src/isa/x64/lower.isle line 1321.

9034

                                return Some(v595);

9035

9036

                            I16X8 => {

9037

                                let v38 = C::unpack_value_array_2(ctx, v37);

9038

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

9039

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9040

                                let v596 = constructor_x64_pmaxsw(ctx, v68, v69);

9041

                                let v597 = constructor_output_xmm(ctx, v596);

9042

                                // Rule at src/isa/x64/lower.isle line 1324.

9043

                                return Some(v597);

9044

9045

                            I32X4 => {

9046

                                let v38 = C::unpack_value_array_2(ctx, v37);

9047

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

9048

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9049

                                let v598 = constructor_x64_pmaxsd(ctx, v68, v69);

9050

                                let v599 = constructor_output_xmm(ctx, v598);

9051

                                // Rule at src/isa/x64/lower.isle line 1327.

9052

                                return Some(v599);

9053

9054

                            _ => {}

9055

9056

                        let v4 = C::fits_in_64(ctx, v3);

9057

                        if let Some(v5) = v4 {

9058

                            let v38 = C::unpack_value_array_2(ctx, v37);

9059

                            let v592 = constructor_cmp_and_choose(ctx, v5, &CC::NL, v38.0, v38.1);

9060

                            let v593 = C::output(ctx, v592);

9061

                            // Rule at src/isa/x64/lower.isle line 1316.

9062

                            return Some(v593);

9063

9064

9065

9066

                &Opcode::Umax => {

9067

                    let v1 = C::first_result(ctx, arg0);

9068

                    if let Some(v2) = v1 {

9069

                        let v3 = C::value_type(ctx, v2);

9070

                        match v3 {

9071

                            I8X16 => {

9072

                                let v38 = C::unpack_value_array_2(ctx, v37);

9073

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

9074

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9075

                                let v606 = constructor_x64_pmaxub(ctx, v68, v69);

9076

                                let v607 = constructor_output_xmm(ctx, v606);

9077

                                // Rule at src/isa/x64/lower.isle line 1343.

9078

                                return Some(v607);

9079

9080

                            I16X8 => {

9081

                                let v38 = C::unpack_value_array_2(ctx, v37);

9082

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

9083

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9084

                                let v608 = constructor_x64_pmaxuw(ctx, v68, v69);

9085

                                let v609 = constructor_output_xmm(ctx, v608);

9086

                                // Rule at src/isa/x64/lower.isle line 1346.

9087

                                return Some(v609);

9088

9089

                            I32X4 => {

9090

                                let v38 = C::unpack_value_array_2(ctx, v37);

9091

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

9092

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9093

                                let v610 = constructor_x64_pmaxud(ctx, v68, v69);

9094

                                let v611 = constructor_output_xmm(ctx, v610);

9095

                                // Rule at src/isa/x64/lower.isle line 1349.

9096

                                return Some(v611);

9097

9098

                            _ => {}

9099

9100

                        let v4 = C::fits_in_64(ctx, v3);

9101

                        if let Some(v5) = v4 {

9102

                            let v38 = C::unpack_value_array_2(ctx, v37);

9103

                            let v586 = constructor_cmp_and_choose(ctx, v5, &CC::NB, v38.0, v38.1);

9104

                            let v587 = C::output(ctx, v586);

9105

                            // Rule at src/isa/x64/lower.isle line 1310.

9106

                            return Some(v587);

9107

9108

9109

9110

                &Opcode::AvgRound => {

9111

                    let v1 = C::first_result(ctx, arg0);

9112

                    if let Some(v2) = v1 {

9113

                        let v3 = C::value_type(ctx, v2);

9114

                        let v64 = C::multi_lane(ctx, v3);

9115

                        if let Some(v65) = v64 {

9116

                            match v65.0 {

9117

                                0x8 => {

9118

                                    if v65.1 == 0x10 {

9119

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9120

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9121

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9122

                                        let v335 = constructor_x64_pavgb(ctx, v68, v69);

9123

                                        let v336 = constructor_output_xmm(ctx, v335);

9124

                                        // Rule at src/isa/x64/lower.isle line 779.

9125

                                        return Some(v336);

9126

9127

9128

                                0x10 => {

9129

                                    if v65.1 == 0x8 {

9130

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9131

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9132

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9133

                                        let v337 = constructor_x64_pavgw(ctx, v68, v69);

9134

                                        let v338 = constructor_output_xmm(ctx, v337);

9135

                                        // Rule at src/isa/x64/lower.isle line 783.

9136

                                        return Some(v338);

9137

9138

9139

                                _ => {}

9140

9141

9142

9143

9144

                &Opcode::UaddSat => {

9145

                    let v1 = C::first_result(ctx, arg0);

9146

                    if let Some(v2) = v1 {

9147

                        let v3 = C::value_type(ctx, v2);

9148

                        let v64 = C::multi_lane(ctx, v3);

9149

                        if let Some(v65) = v64 {

9150

                            match v65.0 {

9151

                                0x8 => {

9152

                                    if v65.1 == 0x10 {

9153

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9154

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9155

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9156

                                        let v108 = constructor_x64_paddusb(ctx, v68, v69);

9157

                                        let v109 = constructor_output_xmm(ctx, v108);

9158

                                        // Rule at src/isa/x64/lower.isle line 126.

9159

                                        return Some(v109);

9160

9161

9162

                                0x10 => {

9163

                                    if v65.1 == 0x8 {

9164

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9165

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9166

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9167

                                        let v110 = constructor_x64_paddusw(ctx, v68, v69);

9168

                                        let v111 = constructor_output_xmm(ctx, v110);

9169

                                        // Rule at src/isa/x64/lower.isle line 130.

9170

                                        return Some(v111);

9171

9172

9173

                                _ => {}

9174

9175

9176

9177

9178

                &Opcode::SaddSat => {

9179

                    let v1 = C::first_result(ctx, arg0);

9180

                    if let Some(v2) = v1 {

9181

                        let v3 = C::value_type(ctx, v2);

9182

                        let v64 = C::multi_lane(ctx, v3);

9183

                        if let Some(v65) = v64 {

9184

                            match v65.0 {

9185

                                0x8 => {

9186

                                    if v65.1 == 0x10 {

9187

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9188

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9189

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9190

                                        let v104 = constructor_x64_paddsb(ctx, v68, v69);

9191

                                        let v105 = constructor_output_xmm(ctx, v104);

9192

                                        // Rule at src/isa/x64/lower.isle line 116.

9193

                                        return Some(v105);

9194

9195

9196

                                0x10 => {

9197

                                    if v65.1 == 0x8 {

9198

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9199

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9200

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9201

                                        let v106 = constructor_x64_paddsw(ctx, v68, v69);

9202

                                        let v107 = constructor_output_xmm(ctx, v106);

9203

                                        // Rule at src/isa/x64/lower.isle line 120.

9204

                                        return Some(v107);

9205

9206

9207

                                _ => {}

9208

9209

9210

9211

9212

                &Opcode::UsubSat => {

9213

                    let v1 = C::first_result(ctx, arg0);

9214

                    if let Some(v2) = v1 {

9215

                        let v3 = C::value_type(ctx, v2);

9216

                        let v64 = C::multi_lane(ctx, v3);

9217

                        if let Some(v65) = v64 {

9218

                            match v65.0 {

9219

                                0x8 => {

9220

                                    if v65.1 == 0x10 {

9221

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9222

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9223

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9224

                                        let v130 = constructor_x64_psubusb(ctx, v68, v69);

9225

                                        let v131 = constructor_output_xmm(ctx, v130);

9226

                                        // Rule at src/isa/x64/lower.isle line 187.

9227

                                        return Some(v131);

9228

9229

9230

                                0x10 => {

9231

                                    if v65.1 == 0x8 {

9232

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9233

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9234

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9235

                                        let v132 = constructor_x64_psubusw(ctx, v68, v69);

9236

                                        let v133 = constructor_output_xmm(ctx, v132);

9237

                                        // Rule at src/isa/x64/lower.isle line 191.

9238

                                        return Some(v133);

9239

9240

9241

                                _ => {}

9242

9243

9244

9245

9246

                &Opcode::SsubSat => {

9247

                    let v1 = C::first_result(ctx, arg0);

9248

                    if let Some(v2) = v1 {

9249

                        let v3 = C::value_type(ctx, v2);

9250

                        let v64 = C::multi_lane(ctx, v3);

9251

                        if let Some(v65) = v64 {

9252

                            match v65.0 {

9253

                                0x8 => {

9254

                                    if v65.1 == 0x10 {

9255

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9256

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9257

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9258

                                        let v126 = constructor_x64_psubsb(ctx, v68, v69);

9259

                                        let v127 = constructor_output_xmm(ctx, v126);

9260

                                        // Rule at src/isa/x64/lower.isle line 177.

9261

                                        return Some(v127);

9262

9263

9264

                                0x10 => {

9265

                                    if v65.1 == 0x8 {

9266

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9267

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9268

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9269

                                        let v128 = constructor_x64_psubsw(ctx, v68, v69);

9270

                                        let v129 = constructor_output_xmm(ctx, v128);

9271

                                        // Rule at src/isa/x64/lower.isle line 181.

9272

                                        return Some(v129);

9273

9274

9275

                                _ => {}

9276

9277

9278

9279

9280

                &Opcode::Iadd => {

9281

                    let v1 = C::first_result(ctx, arg0);

9282

                    if let Some(v2) = v1 {

9283

                        let v3 = C::value_type(ctx, v2);

9284

                        if v3 == I128 {

9285

                            let v38 = C::unpack_value_array_2(ctx, v37);

9286

                            let v78 = C::put_in_regs(ctx, v38.0);

9287

                            let v80 = constructor_value_regs_get_gpr(ctx, v78, 0x0);

9288

                            let v82 = constructor_value_regs_get_gpr(ctx, v78, 0x1);

9289

                            let v83 = C::put_in_regs(ctx, v38.1);

9290

                            let v84 = constructor_value_regs_get_gpr(ctx, v83, 0x0);

9291

                            let v85 = constructor_value_regs_get_gpr(ctx, v83, 0x1);

9292

                            let v86 = &C::gpr_to_gpr_mem_imm(ctx, v84);

9293

                            let v87 = &constructor_x64_add_with_flags_paired(ctx, I64, v80, v86);

9294

                            let v88 = &C::gpr_to_gpr_mem_imm(ctx, v85);

9295

                            let v89 = &constructor_x64_adc_paired(ctx, I64, v82, v88);

9296

                            let v90 = constructor_with_flags(ctx, v87, v89);

9297

                            let v91 = C::output(ctx, v90);

9298

                            // Rule at src/isa/x64/lower.isle line 88.

9299

                            return Some(v91);

9300

9301

                        let v64 = C::multi_lane(ctx, v3);

9302

                        if let Some(v65) = v64 {

9303

                            match v65.0 {

9304

                                0x8 => {

9305

                                    if v65.1 == 0x10 {

9306

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9307

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9308

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9309

                                        let v70 = constructor_x64_paddb(ctx, v68, v69);

9310

                                        let v71 = constructor_output_xmm(ctx, v70);

9311

                                        // Rule at src/isa/x64/lower.isle line 71.

9312

                                        return Some(v71);

9313

9314

9315

                                0x10 => {

9316

                                    if v65.1 == 0x8 {

9317

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9318

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9319

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9320

                                        let v72 = constructor_x64_paddw(ctx, v68, v69);

9321

                                        let v73 = constructor_output_xmm(ctx, v72);

9322

                                        // Rule at src/isa/x64/lower.isle line 75.

9323

                                        return Some(v73);

9324

9325

9326

                                0x20 => {

9327

                                    if v65.1 == 0x4 {

9328

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9329

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9330

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9331

                                        let v74 = constructor_x64_paddd(ctx, v68, v69);

9332

                                        let v75 = constructor_output_xmm(ctx, v74);

9333

                                        // Rule at src/isa/x64/lower.isle line 79.

9334

                                        return Some(v75);

9335

9336

9337

                                0x40 => {

9338

                                    if v65.1 == 0x2 {

9339

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9340

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9341

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9342

                                        let v76 = constructor_x64_paddq(ctx, v68, v69);

9343

                                        let v77 = constructor_output_xmm(ctx, v76);

9344

                                        // Rule at src/isa/x64/lower.isle line 83.

9345

                                        return Some(v77);

9346

9347

9348

                                _ => {}

9349

9350

9351

                        let v4 = C::fits_in_64(ctx, v3);

9352

                        if let Some(v5) = v4 {

9353

                            let v38 = C::unpack_value_array_2(ctx, v37);

9354

                            let v58 = &C::sinkable_load(ctx, v38.0);

9355

                            if let Some(v59) = v58 {

9356

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

9357

                                let v61 = &constructor_sink_load_to_gpr_mem_imm(ctx, v59);

9358

                                let v62 = constructor_x64_add(ctx, v5, v60, v61);

9359

                                let v63 = constructor_output_gpr(ctx, v62);

9360

                                // Rule at src/isa/x64/lower.isle line 65.

9361

                                return Some(v63);

9362

9363

                            let v53 = &C::sinkable_load(ctx, v38.1);

9364

                            if let Some(v54) = v53 {

9365

                                let v41 = constructor_put_in_gpr(ctx, v38.0);

9366

                                let v55 = &constructor_sink_load_to_gpr_mem_imm(ctx, v54);

9367

                                let v56 = constructor_x64_add(ctx, v5, v41, v55);

9368

                                let v57 = constructor_output_gpr(ctx, v56);

9369

                                // Rule at src/isa/x64/lower.isle line 62.

9370

                                return Some(v57);

9371

9372

9373

                        let v45 = C::ty_32_or_64(ctx, v3);

9374

                        if let Some(v46) = v45 {

9375

                            let v48 = C::zero_offset(ctx);

9376

                            let v47 = C::mem_flags_trusted(ctx);

9377

                            let v38 = C::unpack_value_array_2(ctx, v37);

9378

                            let v49 = &constructor_to_amode_add(ctx, v47, v38.0, v38.1, v48);

9379

                            let v50 = &C::amode_to_synthetic_amode(ctx, v49);

9380

                            let v51 = constructor_x64_lea(ctx, v46, v50);

9381

                            let v52 = constructor_output_gpr(ctx, v51);

9382

                            // Rule at src/isa/x64/lower.isle line 56.

9383

                            return Some(v52);

9384

9385

                        let v34 = C::fits_in_16(ctx, v3);

9386

                        if let Some(v35) = v34 {

9387

                            let v38 = C::unpack_value_array_2(ctx, v37);

9388

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

9389

                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

9390

                            let v43 = constructor_x64_add(ctx, v35, v41, v42);

9391

                            let v44 = constructor_output_gpr(ctx, v43);

9392

                            // Rule at src/isa/x64/lower.isle line 45.

9393

                            return Some(v44);

9394

9395

9396

9397

                &Opcode::Isub => {

9398

                    let v1 = C::first_result(ctx, arg0);

9399

                    if let Some(v2) = v1 {

9400

                        let v3 = C::value_type(ctx, v2);

9401

                        if v3 == I128 {

9402

                            let v38 = C::unpack_value_array_2(ctx, v37);

9403

                            let v78 = C::put_in_regs(ctx, v38.0);

9404

                            let v80 = constructor_value_regs_get_gpr(ctx, v78, 0x0);

9405

                            let v82 = constructor_value_regs_get_gpr(ctx, v78, 0x1);

9406

                            let v83 = C::put_in_regs(ctx, v38.1);

9407

                            let v84 = constructor_value_regs_get_gpr(ctx, v83, 0x0);

9408

                            let v85 = constructor_value_regs_get_gpr(ctx, v83, 0x1);

9409

                            let v86 = &C::gpr_to_gpr_mem_imm(ctx, v84);

9410

                            let v122 = &constructor_x64_sub_with_flags_paired(ctx, I64, v80, v86);

9411

                            let v88 = &C::gpr_to_gpr_mem_imm(ctx, v85);

9412

                            let v123 = &constructor_x64_sbb_paired(ctx, I64, v82, v88);

9413

                            let v124 = constructor_with_flags(ctx, v122, v123);

9414

                            let v125 = C::output(ctx, v124);

9415

                            // Rule at src/isa/x64/lower.isle line 162.

9416

                            return Some(v125);

9417

9418

                        let v64 = C::multi_lane(ctx, v3);

9419

                        if let Some(v65) = v64 {

9420

                            match v65.0 {

9421

                                0x8 => {

9422

                                    if v65.1 == 0x10 {

9423

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9424

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9425

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9426

                                        let v114 = constructor_x64_psubb(ctx, v68, v69);

9427

                                        let v115 = constructor_output_xmm(ctx, v114);

9428

                                        // Rule at src/isa/x64/lower.isle line 145.

9429

                                        return Some(v115);

9430

9431

9432

                                0x10 => {

9433

                                    if v65.1 == 0x8 {

9434

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9435

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9436

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9437

                                        let v116 = constructor_x64_psubw(ctx, v68, v69);

9438

                                        let v117 = constructor_output_xmm(ctx, v116);

9439

                                        // Rule at src/isa/x64/lower.isle line 149.

9440

                                        return Some(v117);

9441

9442

9443

                                0x20 => {

9444

                                    if v65.1 == 0x4 {

9445

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9446

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9447

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9448

                                        let v118 = constructor_x64_psubd(ctx, v68, v69);

9449

                                        let v119 = constructor_output_xmm(ctx, v118);

9450

                                        // Rule at src/isa/x64/lower.isle line 153.

9451

                                        return Some(v119);

9452

9453

9454

                                0x40 => {

9455

                                    if v65.1 == 0x2 {

9456

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9457

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9458

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9459

                                        let v120 = constructor_x64_psubq(ctx, v68, v69);

9460

                                        let v121 = constructor_output_xmm(ctx, v120);

9461

                                        // Rule at src/isa/x64/lower.isle line 157.

9462

                                        return Some(v121);

9463

9464

9465

                                _ => {}

9466

9467

9468

                        let v4 = C::fits_in_64(ctx, v3);

9469

                        if let Some(v5) = v4 {

9470

                            let v38 = C::unpack_value_array_2(ctx, v37);

9471

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

9472

                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

9473

                            let v112 = constructor_x64_sub(ctx, v5, v41, v42);

9474

                            let v113 = constructor_output_gpr(ctx, v112);

9475

                            // Rule at src/isa/x64/lower.isle line 139.

9476

                            return Some(v113);

9477

9478

9479

9480

                &Opcode::Imul => {

9481

                    let v1 = C::first_result(ctx, arg0);

9482

                    if let Some(v2) = v1 {

9483

                        let v3 = C::value_type(ctx, v2);

9484

                        let v64 = C::multi_lane(ctx, v3);

9485

                        if let Some(v65) = v64 {

9486

                            if v65.0 == 0x40 {

9487

                                if v65.1 == 0x2 {

9488

                                    let v363 = C::avx512vl_enabled(ctx, v3);

9489

                                    if v363 == true {

9490

                                        let v364 = C::avx512dq_enabled(ctx, v3);

9491

                                        if v364 == true {

9492

                                            let v38 = C::unpack_value_array_2(ctx, v37);

9493

                                            let v365 = &C::put_in_xmm_mem(ctx, v38.0);

9494

                                            let v366 = constructor_put_in_xmm(ctx, v38.1);

9495

                                            let v367 = constructor_x64_vpmullq(ctx, v365, v366);

9496

                                            let v368 = constructor_output_xmm(ctx, v367);

9497

                                            // Rule at src/isa/x64/lower.isle line 855.

9498

                                            return Some(v368);

9499

9500

9501

9502

9503

9504

                        if v3 == I128 {

9505

                            let v38 = C::unpack_value_array_2(ctx, v37);

9506

                            let v78 = C::put_in_regs(ctx, v38.0);

9507

                            let v80 = constructor_value_regs_get_gpr(ctx, v78, 0x0);

9508

                            let v82 = constructor_value_regs_get_gpr(ctx, v78, 0x1);

9509

                            let v83 = C::put_in_regs(ctx, v38.1);

9510

                            let v84 = constructor_value_regs_get_gpr(ctx, v83, 0x0);

9511

                            let v85 = constructor_value_regs_get_gpr(ctx, v83, 0x1);

9512

                            let v345 = &C::gpr_to_gpr_mem_imm(ctx, v85);

9513

                            let v346 = constructor_x64_mul(ctx, I64, v80, v345);

9514

                            let v347 = &C::gpr_to_gpr_mem_imm(ctx, v84);

9515

                            let v348 = constructor_x64_mul(ctx, I64, v82, v347);

9516

                            let v349 = &C::gpr_to_gpr_mem_imm(ctx, v348);

9517

                            let v350 = constructor_x64_add(ctx, I64, v346, v349);

9518

                            let v351 = &C::gpr_to_gpr_mem(ctx, v84);

9519

                            let v352 = constructor_mulhi_u(ctx, I64, v80, v351);

9520

                            let v353 = constructor_value_regs_get_gpr(ctx, v352, 0x0);

9521

                            let v354 = constructor_value_regs_get_gpr(ctx, v352, 0x1);

9522

                            let v355 = &C::gpr_to_gpr_mem_imm(ctx, v354);

9523

                            let v356 = constructor_x64_add(ctx, I64, v350, v355);

9524

                            let v357 = constructor_value_gprs(ctx, v353, v356);

9525

                            let v358 = C::output(ctx, v357);

9526

                            // Rule at src/isa/x64/lower.isle line 820.

9527

                            return Some(v358);

9528

9529

                        if let Some(v65) = v64 {

9530

                            match v65.0 {

9531

                                0x10 => {

9532

                                    if v65.1 == 0x8 {

9533

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9534

                                        let v154 = C::def_inst(ctx, v38.1);

9535

                                        if let Some(v155) = v154 {

9536

                                            let v156 = &C::inst_data(ctx, v155);

9537

                                            if let &InstructionData::Unary {

9538

                                                opcode: ref v157,

9539

                                                arg: v158,

9540

                                            } = v156

9541

9542

                                                match v157 {

9543

                                                    &Opcode::SwidenLow => {

9544

                                                        let v163 = C::def_inst(ctx, v38.0);

9545

                                                        if let Some(v164) = v163 {

9546

                                                            let v165 = &C::inst_data(ctx, v164);

9547

                                                            if let &InstructionData::Unary {

9548

                                                                opcode: ref v166,

9549

                                                                arg: v167,

9550

                                                            } = v165

9551

9552

                                                                if let &Opcode::SwidenLow = v166 {

9553

                                                                    let v387 =

9554

                                                                        C::value_type(ctx, v167);

9555

                                                                    let v388 =

9556

                                                                        C::multi_lane(ctx, v387);

9557

                                                                    if let Some(v389) = v388 {

9558

                                                                        if v389.0 == 0x8 {

9559

                                                                            if v389.1 == 0x10 {

9560

                                                                                let v392 =

9561

                                                                                    C::value_type(

9562

                                                                                        ctx, v158,

9563

);

9564

                                                                                let v393 =

9565

                                                                                    C::multi_lane(

9566

                                                                                        ctx, v392,

9567

);

9568

                                                                                if let Some(v394) =

9569

                                                                                    v393

9570

9571

                                                                                    if v394.0 == 0x8

9572

9573

                                                                                        if v394.1

9574

                                                                                            == 0x10

9575

9576

                                                                                            let v418 = &C::put_in_xmm_mem(ctx, v167);

9577

                                                                                            let v426 = constructor_x64_pmovsxbw(ctx, v418);

9578

                                                                                            let v421 = &C::put_in_xmm_mem(ctx, v158);

9579

                                                                                            let v427 = constructor_x64_pmovsxbw(ctx, v421);

9580

                                                                                            let v428 = &C::xmm_to_xmm_mem(ctx, v427);

9581

                                                                                            let v429 = constructor_x64_pmullw(ctx, v426, v428);

9582

                                                                                            let v430 = constructor_output_xmm(ctx, v429);

9583

                                                                                            // Rule at src/isa/x64/lower.isle line 939.

9584

                                                                                            return Some(v430);

9585

9586

9587

9588

9589

9590

9591

9592

9593

9594

9595

                                                    &Opcode::SwidenHigh => {

9596

                                                        let v163 = C::def_inst(ctx, v38.0);

9597

                                                        if let Some(v164) = v163 {

9598

                                                            let v165 = &C::inst_data(ctx, v164);

9599

                                                            if let &InstructionData::Unary {

9600

                                                                opcode: ref v166,

9601

                                                                arg: v167,

9602

                                                            } = v165

9603

9604

                                                                if let &Opcode::SwidenHigh = v166 {

9605

                                                                    let v387 =

9606

                                                                        C::value_type(ctx, v167);

9607

                                                                    let v388 =

9608

                                                                        C::multi_lane(ctx, v387);

9609

                                                                    if let Some(v389) = v388 {

9610

                                                                        if v389.0 == 0x8 {

9611

                                                                            if v389.1 == 0x10 {

9612

                                                                                let v392 =

9613

                                                                                    C::value_type(

9614

                                                                                        ctx, v158,

9615

);

9616

                                                                                let v393 =

9617

                                                                                    C::multi_lane(

9618

                                                                                        ctx, v392,

9619

);

9620

                                                                                if let Some(v394) =

9621

                                                                                    v393

9622

9623

                                                                                    if v394.0 == 0x8

9624

9625

                                                                                        if v394.1

9626

                                                                                            == 0x10

9627

9628

                                                                                            let v168 = constructor_put_in_xmm(ctx, v167);

9629

                                                                                            let v397 = &C::xmm_to_xmm_mem(ctx, v168);

9630

                                                                                            let v399 = constructor_x64_palignr(ctx, v168, v397, 0x8);

9631

                                                                                            let v400 = &C::xmm_to_xmm_mem(ctx, v399);

9632

                                                                                            let v401 = constructor_x64_pmovsxbw(ctx, v400);

9633

                                                                                            let v402 = constructor_put_in_xmm(ctx, v158);

9634

                                                                                            let v403 = &C::xmm_to_xmm_mem(ctx, v402);

9635

                                                                                            let v404 = constructor_x64_palignr(ctx, v402, v403, 0x8);

9636

                                                                                            let v405 = &C::xmm_to_xmm_mem(ctx, v404);

9637

                                                                                            let v406 = constructor_x64_pmovsxbw(ctx, v405);

9638

                                                                                            let v407 = &C::xmm_to_xmm_mem(ctx, v406);

9639

                                                                                            let v408 = constructor_x64_pmullw(ctx, v401, v407);

9640

                                                                                            let v409 = constructor_output_xmm(ctx, v408);

9641

                                                                                            // Rule at src/isa/x64/lower.isle line 903.

9642

                                                                                            return Some(v409);

9643

9644

9645

9646

9647

9648

9649

9650

9651

9652

9653

                                                    &Opcode::UwidenLow => {

9654

                                                        let v163 = C::def_inst(ctx, v38.0);

9655

                                                        if let Some(v164) = v163 {

9656

                                                            let v165 = &C::inst_data(ctx, v164);

9657

                                                            if let &InstructionData::Unary {

9658

                                                                opcode: ref v166,

9659

                                                                arg: v167,

9660

                                                            } = v165

9661

9662

                                                                if let &Opcode::UwidenLow = v166 {

9663

                                                                    let v387 =

9664

                                                                        C::value_type(ctx, v167);

9665

                                                                    let v388 =

9666

                                                                        C::multi_lane(ctx, v387);

9667

                                                                    if let Some(v389) = v388 {

9668

                                                                        if v389.0 == 0x8 {

9669

                                                                            if v389.1 == 0x10 {

9670

                                                                                let v392 =

9671

                                                                                    C::value_type(

9672

                                                                                        ctx, v158,

9673

);

9674

                                                                                let v393 =

9675

                                                                                    C::multi_lane(

9676

                                                                                        ctx, v392,

9677

);

9678

                                                                                if let Some(v394) =

9679

                                                                                    v393

9680

9681

                                                                                    if v394.0 == 0x8

9682

9683

                                                                                        if v394.1

9684

                                                                                            == 0x10

9685

9686

                                                                                            let v418 = &C::put_in_xmm_mem(ctx, v167);

9687

                                                                                            let v450 = constructor_x64_pmovzxbw(ctx, v418);

9688

                                                                                            let v421 = &C::put_in_xmm_mem(ctx, v158);

9689

                                                                                            let v451 = constructor_x64_pmovzxbw(ctx, v421);

9690

                                                                                            let v452 = &C::xmm_to_xmm_mem(ctx, v451);

9691

                                                                                            let v453 = constructor_x64_pmullw(ctx, v450, v452);

9692

                                                                                            let v454 = constructor_output_xmm(ctx, v453);

9693

                                                                                            // Rule at src/isa/x64/lower.isle line 1007.

9694

                                                                                            return Some(v454);

9695

9696

9697

9698

9699

9700

9701

9702

9703

9704

9705

                                                    &Opcode::UwidenHigh => {

9706

                                                        let v163 = C::def_inst(ctx, v38.0);

9707

                                                        if let Some(v164) = v163 {

9708

                                                            let v165 = &C::inst_data(ctx, v164);

9709

                                                            if let &InstructionData::Unary {

9710

                                                                opcode: ref v166,

9711

                                                                arg: v167,

9712

                                                            } = v165

9713

9714

                                                                if let &Opcode::UwidenHigh = v166 {

9715

                                                                    let v387 =

9716

                                                                        C::value_type(ctx, v167);

9717

                                                                    let v388 =

9718

                                                                        C::multi_lane(ctx, v387);

9719

                                                                    if let Some(v389) = v388 {

9720

                                                                        if v389.0 == 0x8 {

9721

                                                                            if v389.1 == 0x10 {

9722

                                                                                let v392 =

9723

                                                                                    C::value_type(

9724

                                                                                        ctx, v158,

9725

);

9726

                                                                                let v393 =

9727

                                                                                    C::multi_lane(

9728

                                                                                        ctx, v392,

9729

);

9730

                                                                                if let Some(v394) =

9731

                                                                                    v393

9732

9733

                                                                                    if v394.0 == 0x8

9734

9735

                                                                                        if v394.1

9736

                                                                                            == 0x10

9737

9738

                                                                                            let v168 = constructor_put_in_xmm(ctx, v167);

9739

                                                                                            let v397 = &C::xmm_to_xmm_mem(ctx, v168);

9740

                                                                                            let v399 = constructor_x64_palignr(ctx, v168, v397, 0x8);

9741

                                                                                            let v400 = &C::xmm_to_xmm_mem(ctx, v399);

9742

                                                                                            let v439 = constructor_x64_pmovzxbw(ctx, v400);

9743

                                                                                            let v402 = constructor_put_in_xmm(ctx, v158);

9744

                                                                                            let v403 = &C::xmm_to_xmm_mem(ctx, v402);

9745

                                                                                            let v404 = constructor_x64_palignr(ctx, v402, v403, 0x8);

9746

                                                                                            let v405 = &C::xmm_to_xmm_mem(ctx, v404);

9747

                                                                                            let v440 = constructor_x64_pmovzxbw(ctx, v405);

9748

                                                                                            let v441 = &C::xmm_to_xmm_mem(ctx, v440);

9749

                                                                                            let v442 = constructor_x64_pmullw(ctx, v439, v441);

9750

                                                                                            let v443 = constructor_output_xmm(ctx, v442);

9751

                                                                                            // Rule at src/isa/x64/lower.isle line 971.

9752

                                                                                            return Some(v443);

9753

9754

9755

9756

9757

9758

9759

9760

9761

9762

9763

                                                    _ => {}

9764

9765

9766

9767

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

9768

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

9769

                                        let v359 = constructor_x64_pmullw(ctx, v68, v69);

9770

                                        let v360 = constructor_output_xmm(ctx, v359);

9771

                                        // Rule at src/isa/x64/lower.isle line 847.

9772

                                        return Some(v360);

9773

9774

9775

                                0x20 => {

9776

                                    if v65.1 == 0x4 {

9777

                                        let v38 = C::unpack_value_array_2(ctx, v37);

9778

                                        let v154 = C::def_inst(ctx, v38.1);

9779

                                        if let Some(v155) = v154 {

9780

                                            let v156 = &C::inst_data(ctx, v155);

9781

                                            if let &InstructionData::Unary {

9782

                                                opcode: ref v157,

9783

                                                arg: v158,

9784

                                            } = v156

9785

9786

                                                match v157 {

9787

                                                    &Opcode::SwidenLow => {

9788

                                                        let v163 = C::def_inst(ctx, v38.0);

9789

                                                        if let Some(v164) = v163 {

9790

                                                            let v165 = &C::inst_data(ctx, v164);

9791

                                                            if let &InstructionData::Unary {

9792

                                                                opcode: ref v166,

9793

                                                                arg: v167,

9794

                                                            } = v165

9795

9796

                                                                if let &Opcode::SwidenLow = v166 {

9797

                                                                    let v387 =

9798

                                                                        C::value_type(ctx, v167);

9799

                                                                    let v388 =

9800

                                                                        C::multi_lane(ctx, v387);

9801

                                                                    if let Some(v389) = v388 {

9802

                                                                        if v389.0 == 0x10 {

9803

                                                                            if v389.1 == 0x8 {

9804

                                                                                let v392 =

9805

                                                                                    C::value_type(

9806

                                                                                        ctx, v158,

9807

);

9808

                                                                                let v393 =

9809

                                                                                    C::multi_lane(

9810

                                                                                        ctx, v392,

9811

);

9812

                                                                                if let Some(v394) =

9813

                                                                                    v393

9814

9815

                                                                                    if v394.0

9816

                                                                                        == 0x10

9817

9818

                                                                                        if v394.1

9819

                                                                                            == 0x8

9820

9821

                                                                                            let v168 = constructor_put_in_xmm(ctx, v167);

9822

                                                                                            let v410 = constructor_put_in_xmm(ctx, v158);

9823

                                                                                            let v411 = &C::xmm_to_xmm_mem(ctx, v410);

9824

                                                                                            let v412 = constructor_x64_pmullw(ctx, v168, v411);

9825

                                                                                            let v413 = &C::xmm_to_xmm_mem(ctx, v410);

9826

                                                                                            let v414 = constructor_x64_pmulhw(ctx, v168, v413);

9827

                                                                                            let v415 = &C::xmm_to_xmm_mem(ctx, v414);

9828

                                                                                            let v431 = constructor_x64_punpcklwd(ctx, v412, v415);

9829

                                                                                            let v432 = constructor_output_xmm(ctx, v431);

9830

                                                                                            // Rule at src/isa/x64/lower.isle line 949.

9831

                                                                                            return Some(v432);

9832

9833

9834

9835

9836

9837

9838

9839

9840

9841

9842

                                                    &Opcode::SwidenHigh => {

9843

                                                        let v163 = C::def_inst(ctx, v38.0);

9844

                                                        if let Some(v164) = v163 {

9845

                                                            let v165 = &C::inst_data(ctx, v164);

9846

                                                            if let &InstructionData::Unary {

9847

                                                                opcode: ref v166,

9848

                                                                arg: v167,

9849

                                                            } = v165

9850

9851

                                                                if let &Opcode::SwidenHigh = v166 {

9852

                                                                    let v387 =

9853

                                                                        C::value_type(ctx, v167);

9854

                                                                    let v388 =

9855

                                                                        C::multi_lane(ctx, v387);

9856

                                                                    if let Some(v389) = v388 {

9857

                                                                        if v389.0 == 0x10 {

9858

                                                                            if v389.1 == 0x8 {

9859

                                                                                let v392 =

9860

                                                                                    C::value_type(

9861

                                                                                        ctx, v158,

9862

);

9863

                                                                                let v393 =

9864

                                                                                    C::multi_lane(

9865

                                                                                        ctx, v392,

9866

);

9867

                                                                                if let Some(v394) =

9868

                                                                                    v393

9869

9870

                                                                                    if v394.0

9871

                                                                                        == 0x10

9872

9873

                                                                                        if v394.1

9874

                                                                                            == 0x8

9875

9876

                                                                                            let v168 = constructor_put_in_xmm(ctx, v167);

9877

                                                                                            let v410 = constructor_put_in_xmm(ctx, v158);

9878

                                                                                            let v411 = &C::xmm_to_xmm_mem(ctx, v410);

9879

                                                                                            let v412 = constructor_x64_pmullw(ctx, v168, v411);

9880

                                                                                            let v413 = &C::xmm_to_xmm_mem(ctx, v410);

9881

                                                                                            let v414 = constructor_x64_pmulhw(ctx, v168, v413);

9882

                                                                                            let v415 = &C::xmm_to_xmm_mem(ctx, v414);

9883

                                                                                            let v416 = constructor_x64_punpckhwd(ctx, v412, v415);

9884

                                                                                            let v417 = constructor_output_xmm(ctx, v416);

9885

                                                                                            // Rule at src/isa/x64/lower.isle line 917.

9886

                                                                                            return Some(v417);

9887

9888

9889

9890

9891

9892

9893

9894

9895

9896

9897

                                                    &Opcode::UwidenLow => {

9898

                                                        let v163 = C::def_inst(ctx, v38.0);

9899

                                                        if let Some(v164) = v163 {

9900

                                                            let v165 = &C::inst_data(ctx, v164);

9901

                                                            if let &InstructionData::Unary {

9902

                                                                opcode: ref v166,

9903

                                                                arg: v167,

9904

                                                            } = v165

9905

9906

                                                                if let &Opcode::UwidenLow = v166 {

9907

                                                                    let v387 =

9908

                                                                        C::value_type(ctx, v167);

9909

                                                                    let v388 =

9910

                                                                        C::multi_lane(ctx, v387);

9911

                                                                    if let Some(v389) = v388 {

9912

                                                                        if v389.0 == 0x10 {

9913

                                                                            if v389.1 == 0x8 {

9914

                                                                                let v392 =

9915

                                                                                    C::value_type(

9916

                                                                                        ctx, v158,

9917

);

9918

                                                                                let v393 =

9919

                                                                                    C::multi_lane(

9920

                                                                                        ctx, v392,

9921

);

9922

                                                                                if let Some(v394) =

9923

                                                                                    v393

9924

9925

                                                                                    if v394.0

9926

                                                                                        == 0x10

9927

9928

                                                                                        if v394.1

9929

                                                                                            == 0x8

9930

9931

                                                                                            let v168 = constructor_put_in_xmm(ctx, v167);

9932

                                                                                            let v410 = constructor_put_in_xmm(ctx, v158);

9933

                                                                                            let v411 = &C::xmm_to_xmm_mem(ctx, v410);

9934

                                                                                            let v412 = constructor_x64_pmullw(ctx, v168, v411);

9935

                                                                                            let v413 = &C::xmm_to_xmm_mem(ctx, v410);

9936

                                                                                            let v444 = constructor_x64_pmulhuw(ctx, v168, v413);

9937

                                                                                            let v445 = &C::xmm_to_xmm_mem(ctx, v444);

9938

                                                                                            let v455 = constructor_x64_punpcklwd(ctx, v412, v445);

9939

                                                                                            let v456 = constructor_output_xmm(ctx, v455);

9940

                                                                                            // Rule at src/isa/x64/lower.isle line 1017.

9941

                                                                                            return Some(v456);

9942

9943

9944

9945

9946

9947

9948

9949

9950

9951

9952

                                                    &Opcode::UwidenHigh => {

9953

                                                        let v163 = C::def_inst(ctx, v38.0);

9954

                                                        if let Some(v164) = v163 {

9955

                                                            let v165 = &C::inst_data(ctx, v164);

9956

                                                            if let &InstructionData::Unary {

9957

                                                                opcode: ref v166,

9958

                                                                arg: v167,

9959

                                                            } = v165

9960

9961

                                                                if let &Opcode::UwidenHigh = v166 {

9962

                                                                    let v387 =

9963

                                                                        C::value_type(ctx, v167);

9964

                                                                    let v388 =

9965

                                                                        C::multi_lane(ctx, v387);

9966

                                                                    if let Some(v389) = v388 {

9967

                                                                        if v389.0 == 0x10 {

9968

                                                                            if v389.1 == 0x8 {

9969

                                                                                let v392 =

9970

                                                                                    C::value_type(

9971

                                                                                        ctx, v158,

9972

);

9973

                                                                                let v393 =

9974

                                                                                    C::multi_lane(

9975

                                                                                        ctx, v392,

9976

);

9977

                                                                                if let Some(v394) =

9978

                                                                                    v393

9979

9980

                                                                                    if v394.0

9981

                                                                                        == 0x10

9982

9983

                                                                                        if v394.1

9984

                                                                                            == 0x8

9985

9986

                                                                                            let v168 = constructor_put_in_xmm(ctx, v167);

9987

                                                                                            let v410 = constructor_put_in_xmm(ctx, v158);

9988

                                                                                            let v411 = &C::xmm_to_xmm_mem(ctx, v410);

9989

                                                                                            let v412 = constructor_x64_pmullw(ctx, v168, v411);

9990

                                                                                            let v413 = &C::xmm_to_xmm_mem(ctx, v410);

9991

                                                                                            let v444 = constructor_x64_pmulhuw(ctx, v168, v413);

9992

                                                                                            let v445 = &C::xmm_to_xmm_mem(ctx, v444);

9993

                                                                                            let v446 = constructor_x64_punpckhwd(ctx, v412, v445);

9994

                                                                                            let v447 = constructor_output_xmm(ctx, v446);

9995

                                                                                            // Rule at src/isa/x64/lower.isle line 985.

9996

                                                                                            return Some(v447);

9997

9998

9999

10000

10001

10002

10003

10004

10005

10006

10007

                                                    _ => {}

10008

10009

10010

10011

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10012

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10013

                                        let v361 = constructor_x64_pmulld(ctx, v68, v69);

10014

                                        let v362 = constructor_output_xmm(ctx, v361);

10015

                                        // Rule at src/isa/x64/lower.isle line 850.

10016

                                        return Some(v362);

10017

10018

10019

                                0x40 => {

10020

                                    if v65.1 == 0x2 {

10021

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10022

                                        let v154 = C::def_inst(ctx, v38.1);

10023

                                        if let Some(v155) = v154 {

10024

                                            let v156 = &C::inst_data(ctx, v155);

10025

                                            if let &InstructionData::Unary {

10026

                                                opcode: ref v157,

10027

                                                arg: v158,

10028

                                            } = v156

10029

10030

                                                match v157 {

10031

                                                    &Opcode::SwidenLow => {

10032

                                                        let v163 = C::def_inst(ctx, v38.0);

10033

                                                        if let Some(v164) = v163 {

10034

                                                            let v165 = &C::inst_data(ctx, v164);

10035

                                                            if let &InstructionData::Unary {

10036

                                                                opcode: ref v166,

10037

                                                                arg: v167,

10038

                                                            } = v165

10039

10040

                                                                if let &Opcode::SwidenLow = v166 {

10041

                                                                    let v387 =

10042

                                                                        C::value_type(ctx, v167);

10043

                                                                    let v388 =

10044

                                                                        C::multi_lane(ctx, v387);

10045

                                                                    if let Some(v389) = v388 {

10046

                                                                        if v389.0 == 0x20 {

10047

                                                                            if v389.1 == 0x4 {

10048

                                                                                let v392 =

10049

                                                                                    C::value_type(

10050

                                                                                        ctx, v158,

10051

);

10052

                                                                                let v393 =

10053

                                                                                    C::multi_lane(

10054

                                                                                        ctx, v392,

10055

);

10056

                                                                                if let Some(v394) =

10057

                                                                                    v393

10058

10059

                                                                                    if v394.0

10060

                                                                                        == 0x20

10061

10062

                                                                                        if v394.1

10063

                                                                                            == 0x4

10064

10065

                                                                                            let v418 = &C::put_in_xmm_mem(ctx, v167);

10066

                                                                                            let v434 = constructor_x64_pshufd(ctx, v418, 0x50);

10067

                                                                                            let v421 = &C::put_in_xmm_mem(ctx, v158);

10068

                                                                                            let v435 = constructor_x64_pshufd(ctx, v421, 0x50);

10069

                                                                                            let v436 = &C::xmm_to_xmm_mem(ctx, v435);

10070

                                                                                            let v437 = constructor_x64_pmuldq(ctx, v434, v436);

10071

                                                                                            let v438 = constructor_output_xmm(ctx, v437);

10072

                                                                                            // Rule at src/isa/x64/lower.isle line 961.

10073

                                                                                            return Some(v438);

10074

10075

10076

10077

10078

10079

10080

10081

10082

10083

10084

                                                    &Opcode::SwidenHigh => {

10085

                                                        let v163 = C::def_inst(ctx, v38.0);

10086

                                                        if let Some(v164) = v163 {

10087

                                                            let v165 = &C::inst_data(ctx, v164);

10088

                                                            if let &InstructionData::Unary {

10089

                                                                opcode: ref v166,

10090

                                                                arg: v167,

10091

                                                            } = v165

10092

10093

                                                                if let &Opcode::SwidenHigh = v166 {

10094

                                                                    let v387 =

10095

                                                                        C::value_type(ctx, v167);

10096

                                                                    let v388 =

10097

                                                                        C::multi_lane(ctx, v387);

10098

                                                                    if let Some(v389) = v388 {

10099

                                                                        if v389.0 == 0x20 {

10100

                                                                            if v389.1 == 0x4 {

10101

                                                                                let v392 =

10102

                                                                                    C::value_type(

10103

                                                                                        ctx, v158,

10104

);

10105

                                                                                let v393 =

10106

                                                                                    C::multi_lane(

10107

                                                                                        ctx, v392,

10108

);

10109

                                                                                if let Some(v394) =

10110

                                                                                    v393

10111

10112

                                                                                    if v394.0

10113

                                                                                        == 0x20

10114

10115

                                                                                        if v394.1

10116

                                                                                            == 0x4

10117

10118

                                                                                            let v418 = &C::put_in_xmm_mem(ctx, v167);

10119

                                                                                            let v420 = constructor_x64_pshufd(ctx, v418, 0xFA);

10120

                                                                                            let v421 = &C::put_in_xmm_mem(ctx, v158);

10121

                                                                                            let v422 = constructor_x64_pshufd(ctx, v421, 0xFA);

10122

                                                                                            let v423 = &C::xmm_to_xmm_mem(ctx, v422);

10123

                                                                                            let v424 = constructor_x64_pmuldq(ctx, v420, v423);

10124

                                                                                            let v425 = constructor_output_xmm(ctx, v424);

10125

                                                                                            // Rule at src/isa/x64/lower.isle line 929.

10126

                                                                                            return Some(v425);

10127

10128

10129

10130

10131

10132

10133

10134

10135

10136

10137

                                                    &Opcode::UwidenLow => {

10138

                                                        let v163 = C::def_inst(ctx, v38.0);

10139

                                                        if let Some(v164) = v163 {

10140

                                                            let v165 = &C::inst_data(ctx, v164);

10141

                                                            if let &InstructionData::Unary {

10142

                                                                opcode: ref v166,

10143

                                                                arg: v167,

10144

                                                            } = v165

10145

10146

                                                                if let &Opcode::UwidenLow = v166 {

10147

                                                                    let v387 =

10148

                                                                        C::value_type(ctx, v167);

10149

                                                                    let v388 =

10150

                                                                        C::multi_lane(ctx, v387);

10151

                                                                    if let Some(v389) = v388 {

10152

                                                                        if v389.0 == 0x20 {

10153

                                                                            if v389.1 == 0x4 {

10154

                                                                                let v392 =

10155

                                                                                    C::value_type(

10156

                                                                                        ctx, v158,

10157

);

10158

                                                                                let v393 =

10159

                                                                                    C::multi_lane(

10160

                                                                                        ctx, v392,

10161

);

10162

                                                                                if let Some(v394) =

10163

                                                                                    v393

10164

10165

                                                                                    if v394.0

10166

                                                                                        == 0x20

10167

10168

                                                                                        if v394.1

10169

                                                                                            == 0x4

10170

10171

                                                                                            let v418 = &C::put_in_xmm_mem(ctx, v167);

10172

                                                                                            let v434 = constructor_x64_pshufd(ctx, v418, 0x50);

10173

                                                                                            let v421 = &C::put_in_xmm_mem(ctx, v158);

10174

                                                                                            let v435 = constructor_x64_pshufd(ctx, v421, 0x50);

10175

                                                                                            let v436 = &C::xmm_to_xmm_mem(ctx, v435);

10176

                                                                                            let v457 = constructor_x64_pmuludq(ctx, v434, v436);

10177

                                                                                            let v458 = constructor_output_xmm(ctx, v457);

10178

                                                                                            // Rule at src/isa/x64/lower.isle line 1029.

10179

                                                                                            return Some(v458);

10180

10181

10182

10183

10184

10185

10186

10187

10188

10189

10190

                                                    &Opcode::UwidenHigh => {

10191

                                                        let v163 = C::def_inst(ctx, v38.0);

10192

                                                        if let Some(v164) = v163 {

10193

                                                            let v165 = &C::inst_data(ctx, v164);

10194

                                                            if let &InstructionData::Unary {

10195

                                                                opcode: ref v166,

10196

                                                                arg: v167,

10197

                                                            } = v165

10198

10199

                                                                if let &Opcode::UwidenHigh = v166 {

10200

                                                                    let v387 =

10201

                                                                        C::value_type(ctx, v167);

10202

                                                                    let v388 =

10203

                                                                        C::multi_lane(ctx, v387);

10204

                                                                    if let Some(v389) = v388 {

10205

                                                                        if v389.0 == 0x20 {

10206

                                                                            if v389.1 == 0x4 {

10207

                                                                                let v392 =

10208

                                                                                    C::value_type(

10209

                                                                                        ctx, v158,

10210

);

10211

                                                                                let v393 =

10212

                                                                                    C::multi_lane(

10213

                                                                                        ctx, v392,

10214

);

10215

                                                                                if let Some(v394) =

10216

                                                                                    v393

10217

10218

                                                                                    if v394.0

10219

                                                                                        == 0x20

10220

10221

                                                                                        if v394.1

10222

                                                                                            == 0x4

10223

10224

                                                                                            let v418 = &C::put_in_xmm_mem(ctx, v167);

10225

                                                                                            let v420 = constructor_x64_pshufd(ctx, v418, 0xFA);

10226

                                                                                            let v421 = &C::put_in_xmm_mem(ctx, v158);

10227

                                                                                            let v422 = constructor_x64_pshufd(ctx, v421, 0xFA);

10228

                                                                                            let v423 = &C::xmm_to_xmm_mem(ctx, v422);

10229

                                                                                            let v448 = constructor_x64_pmuludq(ctx, v420, v423);

10230

                                                                                            let v449 = constructor_output_xmm(ctx, v448);

10231

                                                                                            // Rule at src/isa/x64/lower.isle line 997.

10232

                                                                                            return Some(v449);

10233

10234

10235

10236

10237

10238

10239

10240

10241

10242

10243

                                                    _ => {}

10244

10245

10246

10247

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10248

                                        let v366 = constructor_put_in_xmm(ctx, v38.1);

10249

                                        let v370 = &C::xmi_imm(ctx, 0x20);

10250

                                        let v371 = constructor_x64_psrlq(ctx, v68, v370);

10251

                                        let v372 = &C::xmm_to_xmm_mem(ctx, v366);

10252

                                        let v373 = constructor_x64_pmuludq(ctx, v371, v372);

10253

                                        let v374 = &C::xmi_imm(ctx, 0x20);

10254

                                        let v375 = constructor_x64_psrlq(ctx, v366, v374);

10255

                                        let v376 = &C::xmm_to_xmm_mem(ctx, v375);

10256

                                        let v377 = constructor_x64_pmuludq(ctx, v68, v376);

10257

                                        let v378 = &C::xmm_to_xmm_mem(ctx, v377);

10258

                                        let v379 = constructor_x64_paddq(ctx, v373, v378);

10259

                                        let v380 = &C::xmi_imm(ctx, 0x20);

10260

                                        let v381 = constructor_x64_psllq(ctx, v379, v380);

10261

                                        let v382 = &C::xmm_to_xmm_mem(ctx, v366);

10262

                                        let v383 = constructor_x64_pmuludq(ctx, v68, v382);

10263

                                        let v384 = &C::xmm_to_xmm_mem(ctx, v381);

10264

                                        let v385 = constructor_x64_paddq(ctx, v383, v384);

10265

                                        let v386 = constructor_output_xmm(ctx, v385);

10266

                                        // Rule at src/isa/x64/lower.isle line 881.

10267

                                        return Some(v386);

10268

10269

10270

                                _ => {}

10271

10272

10273

                        let v4 = C::fits_in_64(ctx, v3);

10274

                        if let Some(v5) = v4 {

10275

                            let v38 = C::unpack_value_array_2(ctx, v37);

10276

                            let v58 = &C::sinkable_load(ctx, v38.0);

10277

                            if let Some(v59) = v58 {

10278

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

10279

                                let v61 = &constructor_sink_load_to_gpr_mem_imm(ctx, v59);

10280

                                let v343 = constructor_x64_mul(ctx, v5, v60, v61);

10281

                                let v344 = constructor_output_gpr(ctx, v343);

10282

                                // Rule at src/isa/x64/lower.isle line 801.

10283

                                return Some(v344);

10284

10285

                            let v140 = &C::simm32_from_value(ctx, v38.0);

10286

                            if let Some(v141) = v140 {

10287

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

10288

                                let v341 = constructor_x64_mul(ctx, v5, v60, v141);

10289

                                let v342 = constructor_output_gpr(ctx, v341);

10290

                                // Rule at src/isa/x64/lower.isle line 798.

10291

                                return Some(v342);

10292

10293

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

10294

                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

10295

                            let v339 = constructor_x64_mul(ctx, v5, v41, v42);

10296

                            let v340 = constructor_output_gpr(ctx, v339);

10297

                            // Rule at src/isa/x64/lower.isle line 792.

10298

                            return Some(v340);

10299

10300

10301

10302

                &Opcode::Umulhi => {

10303

                    let v38 = C::unpack_value_array_2(ctx, v37);

10304

                    let v1756 = C::value_type(ctx, v38.0);

10305

                    match v1756 {

10306

                        I16 => {

10307

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

10308

                            let v1939 = &constructor_put_in_gpr_mem(ctx, v38.1);

10309

                            let v1940 = constructor_mul_hi(ctx, I16, false, v41, v1939);

10310

                            let v1941 = constructor_value_regs_get_gpr(ctx, v1940, 0x1);

10311

                            let v1942 = constructor_output_gpr(ctx, v1941);

10312

                            // Rule at src/isa/x64/lower.isle line 3504.

10313

                            return Some(v1942);

10314

10315

                        I32 => {

10316

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

10317

                            let v1939 = &constructor_put_in_gpr_mem(ctx, v38.1);

10318

                            let v1943 = constructor_mul_hi(ctx, I32, false, v41, v1939);

10319

                            let v1944 = constructor_value_regs_get_gpr(ctx, v1943, 0x1);

10320

                            let v1945 = constructor_output_gpr(ctx, v1944);

10321

                            // Rule at src/isa/x64/lower.isle line 3509.

10322

                            return Some(v1945);

10323

10324

                        I64 => {

10325

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

10326

                            let v1939 = &constructor_put_in_gpr_mem(ctx, v38.1);

10327

                            let v1946 = constructor_mul_hi(ctx, I64, false, v41, v1939);

10328

                            let v1947 = constructor_value_regs_get_gpr(ctx, v1946, 0x1);

10329

                            let v1948 = constructor_output_gpr(ctx, v1947);

10330

                            // Rule at src/isa/x64/lower.isle line 3514.

10331

                            return Some(v1948);

10332

10333

                        _ => {}

10334

10335

10336

                &Opcode::Smulhi => {

10337

                    let v38 = C::unpack_value_array_2(ctx, v37);

10338

                    let v1756 = C::value_type(ctx, v38.0);

10339

                    match v1756 {

10340

                        I16 => {

10341

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

10342

                            let v1939 = &constructor_put_in_gpr_mem(ctx, v38.1);

10343

                            let v1949 = constructor_mul_hi(ctx, I16, true, v41, v1939);

10344

                            let v1950 = constructor_value_regs_get_gpr(ctx, v1949, 0x1);

10345

                            let v1951 = constructor_output_gpr(ctx, v1950);

10346

                            // Rule at src/isa/x64/lower.isle line 3521.

10347

                            return Some(v1951);

10348

10349

                        I32 => {

10350

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

10351

                            let v1939 = &constructor_put_in_gpr_mem(ctx, v38.1);

10352

                            let v1952 = constructor_mul_hi(ctx, I32, true, v41, v1939);

10353

                            let v1953 = constructor_value_regs_get_gpr(ctx, v1952, 0x1);

10354

                            let v1954 = constructor_output_gpr(ctx, v1953);

10355

                            // Rule at src/isa/x64/lower.isle line 3526.

10356

                            return Some(v1954);

10357

10358

                        I64 => {

10359

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

10360

                            let v1939 = &constructor_put_in_gpr_mem(ctx, v38.1);

10361

                            let v1955 = constructor_mul_hi(ctx, I64, true, v41, v1939);

10362

                            let v1956 = constructor_value_regs_get_gpr(ctx, v1955, 0x1);

10363

                            let v1957 = constructor_output_gpr(ctx, v1956);

10364

                            // Rule at src/isa/x64/lower.isle line 3531.

10365

                            return Some(v1957);

10366

10367

                        _ => {}

10368

10369

10370

                &Opcode::SqmulRoundSat => {

10371

                    let v38 = C::unpack_value_array_2(ctx, v37);

10372

                    let v1756 = C::value_type(ctx, v38.0);

10373

                    if v1756 == I16X8 {

10374

                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10375

                        let v366 = constructor_put_in_xmm(ctx, v38.1);

10376

                        let v2223 = C::sqmul_round_sat_mask(ctx);

10377

                        let v2224 = &constructor_const_to_xmm_mem(ctx, v2223);

10378

                        let v372 = &C::xmm_to_xmm_mem(ctx, v366);

10379

                        let v2225 = constructor_x64_pmulhrsw(ctx, v68, v372);

10380

                        let v2226 = constructor_x64_pcmpeqw(ctx, v2225, v2224);

10381

                        let v2227 = &C::xmm_to_xmm_mem(ctx, v2226);

10382

                        let v2228 = constructor_x64_pxor(ctx, v2225, v2227);

10383

                        let v2229 = constructor_output_xmm(ctx, v2228);

10384

                        // Rule at src/isa/x64/lower.isle line 3929.

10385

                        return Some(v2229);

10386

10387

10388

                &Opcode::X86Pmulhrsw => {

10389

                    let v38 = C::unpack_value_array_2(ctx, v37);

10390

                    let v1756 = C::value_type(ctx, v38.0);

10391

                    if v1756 == I16X8 {

10392

                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10393

                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10394

                        let v2230 = constructor_x64_pmulhrsw(ctx, v68, v69);

10395

                        let v2231 = constructor_output_xmm(ctx, v2230);

10396

                        // Rule at src/isa/x64/lower.isle line 3940.

10397

                        return Some(v2231);

10398

10399

10400

                &Opcode::Udiv => {

10401

                    let v38 = C::unpack_value_array_2(ctx, v37);

10402

                    let v1756 = C::value_type(ctx, v38.0);

10403

                    if v1756 == I8 {

10404

                        let v1881 = constructor_extend_to_gpr(ctx, v38.0, I32, &ExtendKind::Zero);

10405

                        let v177 = constructor_put_in_gpr(ctx, v38.1);

10406

                        let v1882 = &C::gpr_to_gpr_mem(ctx, v177);

10407

                        let v1885 = constructor_x64_div8(

10408

                            ctx,

10409

                            v1881,

10410

                            v1882,

10411

                            &DivSignedness::Unsigned,

10412

                            &TrapCode::IntegerDivisionByZero,

10413

);

10414

                        let v1886 = constructor_output_gpr(ctx, v1885);

10415

                        // Rule at src/isa/x64/lower.isle line 3383.

10416

                        return Some(v1886);

10417

10418

                    let v1887 = C::fits_in_64(ctx, v1756);

10419

                    if let Some(v1888) = v1887 {

10420

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

10421

                        let v15 = constructor_imm(ctx, I64, 0x0);

10422

                        let v1889 = C::gpr_new(ctx, v15);

10423

                        let v1890 = constructor_put_in_gpr(ctx, v38.1);

10424

                        let v1891 = &C::gpr_to_gpr_mem(ctx, v1890);

10425

                        let v1892 = &C::raw_operand_size_of_type(ctx, v1888);

10426

                        let v1893 = constructor_x64_div_quotient(

10427

                            ctx,

10428

                            v41,

10429

                            v1889,

10430

                            v1891,

10431

                            v1892,

10432

                            &DivSignedness::Unsigned,

10433

                            &TrapCode::IntegerDivisionByZero,

10434

);

10435

                        let v1894 = C::output(ctx, v1893);

10436

                        // Rule at src/isa/x64/lower.isle line 3392.

10437

                        return Some(v1894);

10438

10439

10440

                &Opcode::Sdiv => {

10441

                    let v38 = C::unpack_value_array_2(ctx, v37);

10442

                    let v1756 = C::value_type(ctx, v38.0);

10443

                    if v1756 == I8 {

10444

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

10445

                        let v1896 = constructor_x64_sign_extend_data(ctx, v41, &OperandSize::Size8);

10446

                        let v1897 = constructor_nonzero_sdiv_divisor(ctx, I8, v38.1);

10447

                        let v1898 = &C::reg_to_gpr_mem(ctx, v1897);

10448

                        let v1901 = constructor_x64_div8(

10449

                            ctx,

10450

                            v1896,

10451

                            v1898,

10452

                            &DivSignedness::Signed,

10453

                            &TrapCode::IntegerOverflow,

10454

);

10455

                        let v1902 = constructor_output_gpr(ctx, v1901);

10456

                        // Rule at src/isa/x64/lower.isle line 3402.

10457

                        return Some(v1902);

10458

10459

                    let v1887 = C::fits_in_64(ctx, v1756);

10460

                    if let Some(v1888) = v1887 {

10461

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

10462

                        let v1903 = &C::raw_operand_size_of_type(ctx, v1888);

10463

                        let v1904 = constructor_x64_sign_extend_data(ctx, v41, v1903);

10464

                        let v1905 = constructor_nonzero_sdiv_divisor(ctx, v1888, v38.1);

10465

                        let v1906 = &C::reg_to_gpr_mem(ctx, v1905);

10466

                        let v1907 = constructor_x64_div_quotient(

10467

                            ctx,

10468

                            v41,

10469

                            v1904,

10470

                            v1906,

10471

                            v1903,

10472

                            &DivSignedness::Signed,

10473

                            &TrapCode::IntegerOverflow,

10474

);

10475

                        let v1908 = C::output(ctx, v1907);

10476

                        // Rule at src/isa/x64/lower.isle line 3408.

10477

                        return Some(v1908);

10478

10479

10480

                &Opcode::Urem => {

10481

                    let v38 = C::unpack_value_array_2(ctx, v37);

10482

                    let v1756 = C::value_type(ctx, v38.0);

10483

                    if v1756 == I8 {

10484

                        let v1881 = constructor_extend_to_gpr(ctx, v38.0, I32, &ExtendKind::Zero);

10485

                        let v177 = constructor_put_in_gpr(ctx, v38.1);

10486

                        let v1882 = &C::gpr_to_gpr_mem(ctx, v177);

10487

                        let v1885 = constructor_x64_div8(

10488

                            ctx,

10489

                            v1881,

10490

                            v1882,

10491

                            &DivSignedness::Unsigned,

10492

                            &TrapCode::IntegerDivisionByZero,

10493

);

10494

                        let v968 = Imm8Reg::Imm8 { imm: 0x8 };

10495

                        let v1909 = &C::imm8_reg_to_imm8_gpr(ctx, &v968);

10496

                        let v1910 = constructor_x64_shr(ctx, I64, v1885, v1909);

10497

                        let v1911 = constructor_output_gpr(ctx, v1910);

10498

                        // Rule at src/isa/x64/lower.isle line 3441.

10499

                        return Some(v1911);

10500

10501

                    let v1887 = C::fits_in_64(ctx, v1756);

10502

                    if let Some(v1888) = v1887 {

10503

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

10504

                        let v15 = constructor_imm(ctx, I64, 0x0);

10505

                        let v1889 = C::gpr_new(ctx, v15);

10506

                        let v1890 = constructor_put_in_gpr(ctx, v38.1);

10507

                        let v1891 = &C::gpr_to_gpr_mem(ctx, v1890);

10508

                        let v1892 = &C::raw_operand_size_of_type(ctx, v1888);

10509

                        let v1912 = constructor_x64_div_remainder(

10510

                            ctx,

10511

                            v41,

10512

                            v1889,

10513

                            v1891,

10514

                            v1892,

10515

                            &DivSignedness::Unsigned,

10516

                            &TrapCode::IntegerDivisionByZero,

10517

);

10518

                        let v1913 = C::output(ctx, v1912);

10519

                        // Rule at src/isa/x64/lower.isle line 3450.

10520

                        return Some(v1913);

10521

10522

10523

                &Opcode::Srem => {

10524

                    let v38 = C::unpack_value_array_2(ctx, v37);

10525

                    let v154 = C::def_inst(ctx, v38.1);

10526

                    if let Some(v155) = v154 {

10527

                        let v156 = &C::inst_data(ctx, v155);

10528

                        if let &InstructionData::UnaryImm {

10529

                            opcode: ref v1914,

10530

                            imm: v1915,

10531

                        } = v156

10532

10533

                            if let &Opcode::Iconst = v1914 {

10534

                                let v1756 = C::value_type(ctx, v38.0);

10535

                                if v1756 == I8 {

10536

                                    let v1916 = C::safe_divisor_from_imm64(ctx, I8, v1915);

10537

                                    if let Some(v1917) = v1916 {

10538

                                        let v41 = constructor_put_in_gpr(ctx, v38.0);

10539

                                        let v1896 = constructor_x64_sign_extend_data(

10540

                                            ctx,

10541

                                            v41,

10542

                                            &OperandSize::Size8,

10543

);

10544

                                        let v1918 = constructor_imm(ctx, I8, v1917);

10545

                                        let v1919 = &C::reg_to_gpr_mem(ctx, v1918);

10546

                                        let v1920 = constructor_x64_div8(

10547

                                            ctx,

10548

                                            v1896,

10549

                                            v1919,

10550

                                            &DivSignedness::Signed,

10551

                                            &TrapCode::IntegerDivisionByZero,

10552

);

10553

                                        let v968 = Imm8Reg::Imm8 { imm: 0x8 };

10554

                                        let v1921 = &C::imm8_reg_to_imm8_gpr(ctx, &v968);

10555

                                        let v1922 = constructor_x64_shr(ctx, I64, v1920, v1921);

10556

                                        let v1923 = constructor_output_gpr(ctx, v1922);

10557

                                        // Rule at src/isa/x64/lower.isle line 3465.

10558

                                        return Some(v1923);

10559

10560

10561

                                let v1924 = C::safe_divisor_from_imm64(ctx, v1756, v1915);

10562

                                if let Some(v1925) = v1924 {

10563

                                    let v41 = constructor_put_in_gpr(ctx, v38.0);

10564

                                    let v1926 = &C::raw_operand_size_of_type(ctx, v1756);

10565

                                    let v1927 = constructor_x64_sign_extend_data(ctx, v41, v1926);

10566

                                    let v1928 = constructor_imm(ctx, v1756, v1925);

10567

                                    let v1929 = &C::reg_to_gpr_mem(ctx, v1928);

10568

                                    let v1930 = constructor_x64_div_remainder(

10569

                                        ctx,

10570

                                        v41,

10571

                                        v1927,

10572

                                        v1929,

10573

                                        v1926,

10574

                                        &DivSignedness::Signed,

10575

                                        &TrapCode::IntegerDivisionByZero,

10576

);

10577

                                    let v1931 = C::output(ctx, v1930);

10578

                                    // Rule at src/isa/x64/lower.isle line 3474.

10579

                                    return Some(v1931);

10580

10581

10582

10583

10584

                    let v1756 = C::value_type(ctx, v38.0);

10585

                    if v1756 == I8 {

10586

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

10587

                        let v1896 = constructor_x64_sign_extend_data(ctx, v41, &OperandSize::Size8);

10588

                        let v1932 = constructor_put_in_gpr(ctx, v38.1);

10589

                        let v1933 = constructor_x64_checked_srem_seq8(ctx, v1896, v1932);

10590

                        let v968 = Imm8Reg::Imm8 { imm: 0x8 };

10591

                        let v1909 = &C::imm8_reg_to_imm8_gpr(ctx, &v968);

10592

                        let v1934 = constructor_x64_shr(ctx, I64, v1933, v1909);

10593

                        let v1935 = constructor_output_gpr(ctx, v1934);

10594

                        // Rule at src/isa/x64/lower.isle line 3487.

10595

                        return Some(v1935);

10596

10597

                    let v41 = constructor_put_in_gpr(ctx, v38.0);

10598

                    let v1926 = &C::raw_operand_size_of_type(ctx, v1756);

10599

                    let v1927 = constructor_x64_sign_extend_data(ctx, v41, v1926);

10600

                    let v1890 = constructor_put_in_gpr(ctx, v38.1);

10601

                    let v1936 = constructor_x64_checked_srem_seq(ctx, v1926, v41, v1927, v1890);

10602

                    let v1937 = C::value_regs_get(ctx, v1936, 0x1);

10603

                    let v1938 = constructor_output_reg(ctx, v1937);

10604

                    // Rule at src/isa/x64/lower.isle line 3493.

10605

                    return Some(v1938);

10606

10607

                &Opcode::IaddCout => {

10608

                    let v38 = C::unpack_value_array_2(ctx, v37);

10609

                    let v92 = C::value_type(ctx, v38.1);

10610

                    let v93 = C::ty_32_or_64(ctx, v92);

10611

                    if let Some(v94) = v93 {

10612

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

10613

                        let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

10614

                        let v95 = &constructor_x64_add_with_flags_paired(ctx, v94, v41, v42);

10615

                        let v97 = &constructor_x64_setcc_paired(ctx, &CC::O);

10616

                        let v98 = constructor_with_flags(ctx, v95, v97);

10617

                        let v99 = C::value_regs_get(ctx, v98, 0x0);

10618

                        let v100 = C::value_reg(ctx, v99);

10619

                        let v101 = C::value_regs_get(ctx, v98, 0x1);

10620

                        let v102 = C::value_reg(ctx, v101);

10621

                        let v103 = C::output_pair(ctx, v100, v102);

10622

                        // Rule at src/isa/x64/lower.isle line 108.

10623

                        return Some(v103);

10624

10625

10626

                &Opcode::Band => {

10627

                    let v1 = C::first_result(ctx, arg0);

10628

                    if let Some(v2) = v1 {

10629

                        let v3 = C::value_type(ctx, v2);

10630

                        let v134 = C::ty_int_ref_scalar_64(ctx, v3);

10631

                        if let Some(v135) = v134 {

10632

                            let v171 = C::use_bmi1(ctx, v3);

10633

                            if v171 == true {

10634

                                let v38 = C::unpack_value_array_2(ctx, v37);

10635

                                let v163 = C::def_inst(ctx, v38.0);

10636

                                if let Some(v164) = v163 {

10637

                                    let v165 = &C::inst_data(ctx, v164);

10638

                                    if let &InstructionData::Unary {

10639

                                        opcode: ref v166,

10640

                                        arg: v167,

10641

                                    } = v165

10642

10643

                                        if let &Opcode::Bnot = v166 {

10644

                                            let v176 = constructor_put_in_gpr(ctx, v167);

10645

                                            let v177 = constructor_put_in_gpr(ctx, v38.1);

10646

                                            let v178 = constructor_x64_andn(ctx, v3, v176, v177);

10647

                                            let v179 = constructor_output_gpr(ctx, v178);

10648

                                            // Rule at src/isa/x64/lower.isle line 270.

10649

                                            return Some(v179);

10650

10651

10652

10653

                                let v154 = C::def_inst(ctx, v38.1);

10654

                                if let Some(v155) = v154 {

10655

                                    let v156 = &C::inst_data(ctx, v155);

10656

                                    if let &InstructionData::Unary {

10657

                                        opcode: ref v157,

10658

                                        arg: v158,

10659

                                    } = v156

10660

10661

                                        if let &Opcode::Bnot = v157 {

10662

                                            let v172 = constructor_put_in_gpr(ctx, v158);

10663

                                            let v173 = constructor_put_in_gpr(ctx, v38.0);

10664

                                            let v174 = constructor_x64_andn(ctx, v3, v172, v173);

10665

                                            let v175 = constructor_output_gpr(ctx, v174);

10666

                                            // Rule at src/isa/x64/lower.isle line 266.

10667

                                            return Some(v175);

10668

10669

10670

10671

10672

10673

                        let v64 = C::multi_lane(ctx, v3);

10674

                        if let Some(v65) = v64 {

10675

                            let v38 = C::unpack_value_array_2(ctx, v37);

10676

                            let v163 = C::def_inst(ctx, v38.0);

10677

                            if let Some(v164) = v163 {

10678

                                let v165 = &C::inst_data(ctx, v164);

10679

                                if let &InstructionData::Unary {

10680

                                    opcode: ref v166,

10681

                                    arg: v167,

10682

                                } = v165

10683

10684

                                    if let &Opcode::Bnot = v166 {

10685

                                        let v168 = constructor_put_in_xmm(ctx, v167);

10686

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10687

                                        let v169 = constructor_sse_and_not(ctx, v3, v168, v69);

10688

                                        let v170 = constructor_output_xmm(ctx, v169);

10689

                                        // Rule at src/isa/x64/lower.isle line 263.

10690

                                        return Some(v170);

10691

10692

10693

10694

                            let v154 = C::def_inst(ctx, v38.1);

10695

                            if let Some(v155) = v154 {

10696

                                let v156 = &C::inst_data(ctx, v155);

10697

                                if let &InstructionData::Unary {

10698

                                    opcode: ref v157,

10699

                                    arg: v158,

10700

                                } = v156

10701

10702

                                    if let &Opcode::Bnot = v157 {

10703

                                        let v159 = constructor_put_in_xmm(ctx, v158);

10704

                                        let v160 = &C::put_in_xmm_mem(ctx, v38.0);

10705

                                        let v161 = constructor_sse_and_not(ctx, v3, v159, v160);

10706

                                        let v162 = constructor_output_xmm(ctx, v161);

10707

                                        // Rule at src/isa/x64/lower.isle line 261.

10708

                                        return Some(v162);

10709

10710

10711

10712

10713

                        if v3 == I128 {

10714

                            let v38 = C::unpack_value_array_2(ctx, v37);

10715

                            let v78 = C::put_in_regs(ctx, v38.0);

10716

                            let v80 = constructor_value_regs_get_gpr(ctx, v78, 0x0);

10717

                            let v82 = constructor_value_regs_get_gpr(ctx, v78, 0x1);

10718

                            let v83 = C::put_in_regs(ctx, v38.1);

10719

                            let v84 = constructor_value_regs_get_gpr(ctx, v83, 0x0);

10720

                            let v85 = constructor_value_regs_get_gpr(ctx, v83, 0x1);

10721

                            let v86 = &C::gpr_to_gpr_mem_imm(ctx, v84);

10722

                            let v150 = constructor_x64_and(ctx, I64, v80, v86);

10723

                            let v88 = &C::gpr_to_gpr_mem_imm(ctx, v85);

10724

                            let v151 = constructor_x64_and(ctx, I64, v82, v88);

10725

                            let v152 = constructor_value_gprs(ctx, v150, v151);

10726

                            let v153 = C::output(ctx, v152);

10727

                            // Rule at src/isa/x64/lower.isle line 235.

10728

                            return Some(v153);

10729

10730

                        if let Some(v65) = v64 {

10731

                            let v38 = C::unpack_value_array_2(ctx, v37);

10732

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

10733

                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10734

                            let v148 = constructor_sse_and(ctx, v3, v68, v69);

10735

                            let v149 = constructor_output_xmm(ctx, v148);

10736

                            // Rule at src/isa/x64/lower.isle line 229.

10737

                            return Some(v149);

10738

10739

                        let v144 = C::ty_scalar_float(ctx, v3);

10740

                        if let Some(v145) = v144 {

10741

                            let v38 = C::unpack_value_array_2(ctx, v37);

10742

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

10743

                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10744

                            let v146 = constructor_sse_and(ctx, v145, v68, v69);

10745

                            let v147 = constructor_output_xmm(ctx, v146);

10746

                            // Rule at src/isa/x64/lower.isle line 217.

10747

                            return Some(v147);

10748

10749

                        if let Some(v135) = v134 {

10750

                            let v38 = C::unpack_value_array_2(ctx, v37);

10751

                            let v140 = &C::simm32_from_value(ctx, v38.0);

10752

                            if let Some(v141) = v140 {

10753

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

10754

                                let v142 = constructor_x64_and(ctx, v3, v60, v141);

10755

                                let v143 = constructor_output_gpr(ctx, v142);

10756

                                // Rule at src/isa/x64/lower.isle line 211.

10757

                                return Some(v143);

10758

10759

                            let v58 = &C::sinkable_load(ctx, v38.0);

10760

                            if let Some(v59) = v58 {

10761

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

10762

                                let v61 = &constructor_sink_load_to_gpr_mem_imm(ctx, v59);

10763

                                let v138 = constructor_x64_and(ctx, v3, v60, v61);

10764

                                let v139 = constructor_output_gpr(ctx, v138);

10765

                                // Rule at src/isa/x64/lower.isle line 207.

10766

                                return Some(v139);

10767

10768

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

10769

                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

10770

                            let v136 = constructor_x64_and(ctx, v3, v41, v42);

10771

                            let v137 = constructor_output_gpr(ctx, v136);

10772

                            // Rule at src/isa/x64/lower.isle line 200.

10773

                            return Some(v137);

10774

10775

10776

10777

                &Opcode::Bor => {

10778

                    let v1 = C::first_result(ctx, arg0);

10779

                    if let Some(v2) = v1 {

10780

                        let v3 = C::value_type(ctx, v2);

10781

                        if v3 == I128 {

10782

                            let v38 = C::unpack_value_array_2(ctx, v37);

10783

                            let v78 = C::put_in_regs(ctx, v38.0);

10784

                            let v190 = C::put_in_regs(ctx, v38.1);

10785

                            let v191 = constructor_or_i128(ctx, v78, v190);

10786

                            let v192 = C::output(ctx, v191);

10787

                            // Rule at src/isa/x64/lower.isle line 324.

10788

                            return Some(v192);

10789

10790

                        let v64 = C::multi_lane(ctx, v3);

10791

                        if let Some(v65) = v64 {

10792

                            let v38 = C::unpack_value_array_2(ctx, v37);

10793

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

10794

                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10795

                            let v188 = constructor_sse_or(ctx, v3, v68, v69);

10796

                            let v189 = constructor_output_xmm(ctx, v188);

10797

                            // Rule at src/isa/x64/lower.isle line 309.

10798

                            return Some(v189);

10799

10800

                        let v144 = C::ty_scalar_float(ctx, v3);

10801

                        if let Some(v145) = v144 {

10802

                            let v38 = C::unpack_value_array_2(ctx, v37);

10803

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

10804

                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10805

                            let v186 = constructor_sse_or(ctx, v145, v68, v69);

10806

                            let v187 = constructor_output_xmm(ctx, v186);

10807

                            // Rule at src/isa/x64/lower.isle line 297.

10808

                            return Some(v187);

10809

10810

                        let v134 = C::ty_int_ref_scalar_64(ctx, v3);

10811

                        if let Some(v135) = v134 {

10812

                            let v38 = C::unpack_value_array_2(ctx, v37);

10813

                            let v140 = &C::simm32_from_value(ctx, v38.0);

10814

                            if let Some(v141) = v140 {

10815

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

10816

                                let v184 = constructor_x64_or(ctx, v3, v60, v141);

10817

                                let v185 = constructor_output_gpr(ctx, v184);

10818

                                // Rule at src/isa/x64/lower.isle line 291.

10819

                                return Some(v185);

10820

10821

                            let v58 = &C::sinkable_load(ctx, v38.0);

10822

                            if let Some(v59) = v58 {

10823

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

10824

                                let v61 = &constructor_sink_load_to_gpr_mem_imm(ctx, v59);

10825

                                let v182 = constructor_x64_or(ctx, v3, v60, v61);

10826

                                let v183 = constructor_output_gpr(ctx, v182);

10827

                                // Rule at src/isa/x64/lower.isle line 287.

10828

                                return Some(v183);

10829

10830

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

10831

                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

10832

                            let v180 = constructor_x64_or(ctx, v3, v41, v42);

10833

                            let v181 = constructor_output_gpr(ctx, v180);

10834

                            // Rule at src/isa/x64/lower.isle line 280.

10835

                            return Some(v181);

10836

10837

10838

10839

                &Opcode::Bxor => {

10840

                    let v1 = C::first_result(ctx, arg0);

10841

                    if let Some(v2) = v1 {

10842

                        let v3 = C::value_type(ctx, v2);

10843

                        if v3 == I128 {

10844

                            let v38 = C::unpack_value_array_2(ctx, v37);

10845

                            let v78 = C::put_in_regs(ctx, v38.0);

10846

                            let v80 = constructor_value_regs_get_gpr(ctx, v78, 0x0);

10847

                            let v82 = constructor_value_regs_get_gpr(ctx, v78, 0x1);

10848

                            let v83 = C::put_in_regs(ctx, v38.1);

10849

                            let v84 = constructor_value_regs_get_gpr(ctx, v83, 0x0);

10850

                            let v85 = constructor_value_regs_get_gpr(ctx, v83, 0x1);

10851

                            let v86 = &C::gpr_to_gpr_mem_imm(ctx, v84);

10852

                            let v203 = constructor_x64_xor(ctx, I64, v80, v86);

10853

                            let v88 = &C::gpr_to_gpr_mem_imm(ctx, v85);

10854

                            let v204 = constructor_x64_xor(ctx, I64, v82, v88);

10855

                            let v205 = constructor_value_gprs(ctx, v203, v204);

10856

                            let v206 = C::output(ctx, v205);

10857

                            // Rule at src/isa/x64/lower.isle line 359.

10858

                            return Some(v206);

10859

10860

                        let v64 = C::multi_lane(ctx, v3);

10861

                        if let Some(v65) = v64 {

10862

                            let v38 = C::unpack_value_array_2(ctx, v37);

10863

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

10864

                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10865

                            let v201 = constructor_x64_xor_vector(ctx, v3, v68, v69);

10866

                            let v202 = constructor_output_xmm(ctx, v201);

10867

                            // Rule at src/isa/x64/lower.isle line 354.

10868

                            return Some(v202);

10869

10870

                        let v144 = C::ty_scalar_float(ctx, v3);

10871

                        if let Some(v145) = v144 {

10872

                            let v38 = C::unpack_value_array_2(ctx, v37);

10873

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

10874

                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10875

                            let v199 = constructor_x64_xor_vector(ctx, v145, v68, v69);

10876

                            let v200 = constructor_output_xmm(ctx, v199);

10877

                            // Rule at src/isa/x64/lower.isle line 349.

10878

                            return Some(v200);

10879

10880

                        let v134 = C::ty_int_ref_scalar_64(ctx, v3);

10881

                        if let Some(v135) = v134 {

10882

                            let v38 = C::unpack_value_array_2(ctx, v37);

10883

                            let v140 = &C::simm32_from_value(ctx, v38.0);

10884

                            if let Some(v141) = v140 {

10885

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

10886

                                let v197 = constructor_x64_xor(ctx, v3, v60, v141);

10887

                                let v198 = constructor_output_gpr(ctx, v197);

10888

                                // Rule at src/isa/x64/lower.isle line 343.

10889

                                return Some(v198);

10890

10891

                            let v58 = &C::sinkable_load(ctx, v38.0);

10892

                            if let Some(v59) = v58 {

10893

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

10894

                                let v61 = &constructor_sink_load_to_gpr_mem_imm(ctx, v59);

10895

                                let v195 = constructor_x64_xor(ctx, v3, v60, v61);

10896

                                let v196 = constructor_output_gpr(ctx, v195);

10897

                                // Rule at src/isa/x64/lower.isle line 339.

10898

                                return Some(v196);

10899

10900

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

10901

                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

10902

                            let v193 = constructor_x64_xor(ctx, v3, v41, v42);

10903

                            let v194 = constructor_output_gpr(ctx, v193);

10904

                            // Rule at src/isa/x64/lower.isle line 332.

10905

                            return Some(v194);

10906

10907

10908

10909

                &Opcode::Rotl => {

10910

                    let v1 = C::first_result(ctx, arg0);

10911

                    if let Some(v2) = v1 {

10912

                        let v3 = C::value_type(ctx, v2);

10913

                        if v3 == I128 {

10914

                            let v38 = C::unpack_value_array_2(ctx, v37);

10915

                            let v78 = C::put_in_regs(ctx, v38.0);

10916

                            let v284 = constructor_lo_gpr(ctx, v38.1);

10917

                            let v285 = constructor_shl_i128(ctx, v78, v284);

10918

                            let v287 = constructor_imm(ctx, I64, 0x80);

10919

                            let v288 = C::gpr_new(ctx, v287);

10920

                            let v289 = &C::gpr_to_gpr_mem_imm(ctx, v284);

10921

                            let v290 = constructor_x64_sub(ctx, I64, v288, v289);

10922

                            let v291 = constructor_shr_i128(ctx, v78, v290);

10923

                            let v292 = constructor_or_i128(ctx, v285, v291);

10924

                            let v293 = C::output(ctx, v292);

10925

                            // Rule at src/isa/x64/lower.isle line 716.

10926

                            return Some(v293);

10927

10928

                        let v4 = C::fits_in_64(ctx, v3);

10929

                        if let Some(v5) = v4 {

10930

                            let v38 = C::unpack_value_array_2(ctx, v37);

10931

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

10932

                            let v207 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, v5);

10933

                            let v282 = constructor_x64_rotl(ctx, v5, v41, v207);

10934

                            let v283 = constructor_output_gpr(ctx, v282);

10935

                            // Rule at src/isa/x64/lower.isle line 710.

10936

                            return Some(v283);

10937

10938

10939

10940

                &Opcode::Rotr => {

10941

                    let v1 = C::first_result(ctx, arg0);

10942

                    if let Some(v2) = v1 {

10943

                        let v3 = C::value_type(ctx, v2);

10944

                        if v3 == I128 {

10945

                            let v38 = C::unpack_value_array_2(ctx, v37);

10946

                            let v78 = C::put_in_regs(ctx, v38.0);

10947

                            let v284 = constructor_lo_gpr(ctx, v38.1);

10948

                            let v296 = constructor_shr_i128(ctx, v78, v284);

10949

                            let v287 = constructor_imm(ctx, I64, 0x80);

10950

                            let v288 = C::gpr_new(ctx, v287);

10951

                            let v289 = &C::gpr_to_gpr_mem_imm(ctx, v284);

10952

                            let v290 = constructor_x64_sub(ctx, I64, v288, v289);

10953

                            let v297 = constructor_shl_i128(ctx, v78, v290);

10954

                            let v298 = constructor_or_i128(ctx, v296, v297);

10955

                            let v299 = C::output(ctx, v298);

10956

                            // Rule at src/isa/x64/lower.isle line 737.

10957

                            return Some(v299);

10958

10959

                        let v4 = C::fits_in_64(ctx, v3);

10960

                        if let Some(v5) = v4 {

10961

                            let v38 = C::unpack_value_array_2(ctx, v37);

10962

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

10963

                            let v207 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, v5);

10964

                            let v294 = constructor_x64_rotr(ctx, v5, v41, v207);

10965

                            let v295 = constructor_output_gpr(ctx, v294);

10966

                            // Rule at src/isa/x64/lower.isle line 731.

10967

                            return Some(v295);

10968

10969

10970

10971

                &Opcode::Ishl => {

10972

                    let v1 = C::first_result(ctx, arg0);

10973

                    if let Some(v2) = v1 {

10974

                        let v3 = C::value_type(ctx, v2);

10975

                        match v3 {

10976

                            I128 => {

10977

                                let v38 = C::unpack_value_array_2(ctx, v37);

10978

                                let v210 = constructor_lo_gpr(ctx, v38.1);

10979

                                let v211 = C::put_in_regs(ctx, v38.0);

10980

                                let v212 = constructor_shl_i128(ctx, v211, v210);

10981

                                let v213 = C::output(ctx, v212);

10982

                                // Rule at src/isa/x64/lower.isle line 412.

10983

                                return Some(v213);

10984

10985

                            I8X16 => {

10986

                                let v38 = C::unpack_value_array_2(ctx, v37);

10987

                                let v214 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

10988

                                let v215 = constructor_put_in_xmm(ctx, v38.0);

10989

                                let v216 = &constructor_mov_rmi_to_xmm(ctx, v214);

10990

                                let v217 = constructor_x64_psllw(ctx, v215, v216);

10991

                                let v218 = &constructor_ishl_i8x16_mask(ctx, v214);

10992

                                let v221 = constructor_x64_load(ctx, I8X16, v218, &ExtKind::None);

10993

                                let v222 = RegMem::Reg { reg: v221 };

10994

                                let v223 = &C::reg_mem_to_xmm_mem(ctx, &v222);

10995

                                let v224 = constructor_sse_and(ctx, I8X16, v217, v223);

10996

                                let v225 = constructor_output_xmm(ctx, v224);

10997

                                // Rule at src/isa/x64/lower.isle line 424.

10998

                                return Some(v225);

10999

11000

                            I16X8 => {

11001

                                let v38 = C::unpack_value_array_2(ctx, v37);

11002

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11003

                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

11004

                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);

11005

                                let v228 = constructor_x64_psllw(ctx, v68, v227);

11006

                                let v229 = constructor_output_xmm(ctx, v228);

11007

                                // Rule at src/isa/x64/lower.isle line 469.

11008

                                return Some(v229);

11009

11010

                            I32X4 => {

11011

                                let v38 = C::unpack_value_array_2(ctx, v37);

11012

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11013

                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

11014

                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);

11015

                                let v230 = constructor_x64_pslld(ctx, v68, v227);

11016

                                let v231 = constructor_output_xmm(ctx, v230);

11017

                                // Rule at src/isa/x64/lower.isle line 472.

11018

                                return Some(v231);

11019

11020

                            I64X2 => {

11021

                                let v38 = C::unpack_value_array_2(ctx, v37);

11022

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11023

                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

11024

                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);

11025

                                let v232 = constructor_x64_psllq(ctx, v68, v227);

11026

                                let v233 = constructor_output_xmm(ctx, v232);

11027

                                // Rule at src/isa/x64/lower.isle line 475.

11028

                                return Some(v233);

11029

11030

                            _ => {}

11031

11032

                        let v4 = C::fits_in_64(ctx, v3);

11033

                        if let Some(v5) = v4 {

11034

                            let v38 = C::unpack_value_array_2(ctx, v37);

11035

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

11036

                            let v207 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, v5);

11037

                            let v208 = constructor_x64_shl(ctx, v5, v41, v207);

11038

                            let v209 = constructor_output_gpr(ctx, v208);

11039

                            // Rule at src/isa/x64/lower.isle line 373.

11040

                            return Some(v209);

11041

11042

11043

11044

                &Opcode::Ushr => {

11045

                    let v1 = C::first_result(ctx, arg0);

11046

                    if let Some(v2) = v1 {

11047

                        let v3 = C::value_type(ctx, v2);

11048

                        match v3 {

11049

                            I128 => {

11050

                                let v38 = C::unpack_value_array_2(ctx, v37);

11051

                                let v210 = constructor_lo_gpr(ctx, v38.1);

11052

                                let v211 = C::put_in_regs(ctx, v38.0);

11053

                                let v238 = constructor_shr_i128(ctx, v211, v210);

11054

                                let v239 = C::output(ctx, v238);

11055

                                // Rule at src/isa/x64/lower.isle line 519.

11056

                                return Some(v239);

11057

11058

                            I8X16 => {

11059

                                let v38 = C::unpack_value_array_2(ctx, v37);

11060

                                let v214 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

11061

                                let v215 = constructor_put_in_xmm(ctx, v38.0);

11062

                                let v216 = &constructor_mov_rmi_to_xmm(ctx, v214);

11063

                                let v240 = constructor_x64_psrlw(ctx, v215, v216);

11064

                                let v241 = &constructor_ushr_i8x16_mask(ctx, v214);

11065

                                let v242 = &constructor_synthetic_amode_to_xmm_mem(ctx, v241);

11066

                                let v243 = constructor_sse_and(ctx, I8X16, v240, v242);

11067

                                let v244 = constructor_output_xmm(ctx, v243);

11068

                                // Rule at src/isa/x64/lower.isle line 529.

11069

                                return Some(v244);

11070

11071

                            I16X8 => {

11072

                                let v38 = C::unpack_value_array_2(ctx, v37);

11073

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11074

                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

11075

                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);

11076

                                let v245 = constructor_x64_psrlw(ctx, v68, v227);

11077

                                let v246 = constructor_output_xmm(ctx, v245);

11078

                                // Rule at src/isa/x64/lower.isle line 575.

11079

                                return Some(v246);

11080

11081

                            I32X4 => {

11082

                                let v38 = C::unpack_value_array_2(ctx, v37);

11083

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11084

                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

11085

                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);

11086

                                let v247 = constructor_x64_psrld(ctx, v68, v227);

11087

                                let v248 = constructor_output_xmm(ctx, v247);

11088

                                // Rule at src/isa/x64/lower.isle line 578.

11089

                                return Some(v248);

11090

11091

                            I64X2 => {

11092

                                let v38 = C::unpack_value_array_2(ctx, v37);

11093

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11094

                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

11095

                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);

11096

                                let v249 = constructor_x64_psrlq(ctx, v68, v227);

11097

                                let v250 = constructor_output_xmm(ctx, v249);

11098

                                // Rule at src/isa/x64/lower.isle line 581.

11099

                                return Some(v250);

11100

11101

                            _ => {}

11102

11103

                        let v4 = C::fits_in_64(ctx, v3);

11104

                        if let Some(v5) = v4 {

11105

                            let v38 = C::unpack_value_array_2(ctx, v37);

11106

                            let v235 = constructor_extend_to_gpr(ctx, v38.0, v5, &ExtendKind::Zero);

11107

                            let v207 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, v5);

11108

                            let v236 = constructor_x64_shr(ctx, v5, v235, v207);

11109

                            let v237 = constructor_output_gpr(ctx, v236);

11110

                            // Rule at src/isa/x64/lower.isle line 482.

11111

                            return Some(v237);

11112

11113

11114

11115

                &Opcode::Sshr => {

11116

                    let v1 = C::first_result(ctx, arg0);

11117

                    if let Some(v2) = v1 {

11118

                        let v3 = C::value_type(ctx, v2);

11119

                        match v3 {

11120

                            I128 => {

11121

                                let v38 = C::unpack_value_array_2(ctx, v37);

11122

                                let v210 = constructor_lo_gpr(ctx, v38.1);

11123

                                let v211 = C::put_in_regs(ctx, v38.0);

11124

                                let v255 = constructor_sar_i128(ctx, v211, v210);

11125

                                let v256 = C::output(ctx, v255);

11126

                                // Rule at src/isa/x64/lower.isle line 631.

11127

                                return Some(v256);

11128

11129

                            I8X16 => {

11130

                                let v38 = C::unpack_value_array_2(ctx, v37);

11131

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11132

                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

11133

                                let v257 = &C::xmm_to_xmm_mem(ctx, v68);

11134

                                let v258 = constructor_x64_punpcklbw(ctx, v68, v257);

11135

                                let v259 = &C::xmm_to_xmm_mem(ctx, v68);

11136

                                let v260 = constructor_x64_punpckhbw(ctx, v68, v259);

11137

                                let v92 = C::value_type(ctx, v38.1);

11138

                                let v261 = &constructor_sshr_i8x16_bigger_shift(ctx, v92, v226);

11139

                                let v262 = constructor_x64_psraw(ctx, v258, v261);

11140

                                let v263 = constructor_x64_psraw(ctx, v260, v261);

11141

                                let v264 = &C::xmm_to_xmm_mem(ctx, v263);

11142

                                let v265 = constructor_x64_packsswb(ctx, v262, v264);

11143

                                let v266 = constructor_output_xmm(ctx, v265);

11144

                                // Rule at src/isa/x64/lower.isle line 652.

11145

                                return Some(v266);

11146

11147

                            I16X8 => {

11148

                                let v38 = C::unpack_value_array_2(ctx, v37);

11149

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11150

                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

11151

                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);

11152

                                let v267 = constructor_x64_psraw(ctx, v68, v227);

11153

                                let v268 = constructor_output_xmm(ctx, v267);

11154

                                // Rule at src/isa/x64/lower.isle line 681.

11155

                                return Some(v268);

11156

11157

                            I32X4 => {

11158

                                let v38 = C::unpack_value_array_2(ctx, v37);

11159

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11160

                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

11161

                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);

11162

                                let v269 = constructor_x64_psrad(ctx, v68, v227);

11163

                                let v270 = constructor_output_xmm(ctx, v269);

11164

                                // Rule at src/isa/x64/lower.isle line 684.

11165

                                return Some(v270);

11166

11167

                            I64X2 => {

11168

                                let v38 = C::unpack_value_array_2(ctx, v37);

11169

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11170

                                let v272 = constructor_x64_pextrq(ctx, v68, 0x0);

11171

                                let v274 = constructor_x64_pextrq(ctx, v68, 0x1);

11172

                                let v275 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, I64);

11173

                                let v276 = constructor_x64_sar(ctx, I64, v272, v275);

11174

                                let v277 = constructor_x64_sar(ctx, I64, v274, v275);

11175

                                let v278 = &C::gpr_to_gpr_mem(ctx, v276);

11176

                                let v279 = &C::gpr_to_gpr_mem(ctx, v277);

11177

                                let v280 = constructor_make_i64x2_from_lanes(ctx, v278, v279);

11178

                                let v281 = constructor_output_xmm(ctx, v280);

11179

                                // Rule at src/isa/x64/lower.isle line 695.

11180

                                return Some(v281);

11181

11182

                            _ => {}

11183

11184

                        let v4 = C::fits_in_64(ctx, v3);

11185

                        if let Some(v5) = v4 {

11186

                            let v38 = C::unpack_value_array_2(ctx, v37);

11187

                            let v252 = constructor_extend_to_gpr(ctx, v38.0, v5, &ExtendKind::Sign);

11188

                            let v207 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, v5);

11189

                            let v253 = constructor_x64_sar(ctx, v5, v252, v207);

11190

                            let v254 = constructor_output_gpr(ctx, v253);

11191

                            // Rule at src/isa/x64/lower.isle line 594.

11192

                            return Some(v254);

11193

11194

11195

11196

                &Opcode::Fadd => {

11197

                    let v1 = C::first_result(ctx, arg0);

11198

                    if let Some(v2) = v1 {

11199

                        let v3 = C::value_type(ctx, v2);

11200

                        match v3 {

11201

                            F32 => {

11202

                                let v38 = C::unpack_value_array_2(ctx, v37);

11203

                                let v58 = &C::sinkable_load(ctx, v38.0);

11204

                                if let Some(v59) = v58 {

11205

                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);

11206

                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);

11207

                                    let v1025 = constructor_x64_addss(ctx, v1013, v1024);

11208

                                    let v1026 = constructor_output_xmm(ctx, v1025);

11209

                                    // Rule at src/isa/x64/lower.isle line 2041.

11210

                                    return Some(v1026);

11211

11212

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11213

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11214

                                let v1016 = constructor_x64_addss(ctx, v68, v69);

11215

                                let v1017 = constructor_output_xmm(ctx, v1016);

11216

                                // Rule at src/isa/x64/lower.isle line 2030.

11217

                                return Some(v1017);

11218

11219

                            F64 => {

11220

                                let v38 = C::unpack_value_array_2(ctx, v37);

11221

                                let v58 = &C::sinkable_load(ctx, v38.0);

11222

                                if let Some(v59) = v58 {

11223

                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);

11224

                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);

11225

                                    let v1027 = constructor_x64_addsd(ctx, v1013, v1024);

11226

                                    let v1028 = constructor_output_xmm(ctx, v1027);

11227

                                    // Rule at src/isa/x64/lower.isle line 2043.

11228

                                    return Some(v1028);

11229

11230

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11231

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11232

                                let v1018 = constructor_x64_addsd(ctx, v68, v69);

11233

                                let v1019 = constructor_output_xmm(ctx, v1018);

11234

                                // Rule at src/isa/x64/lower.isle line 2032.

11235

                                return Some(v1019);

11236

11237

                            F32X4 => {

11238

                                let v38 = C::unpack_value_array_2(ctx, v37);

11239

                                let v58 = &C::sinkable_load(ctx, v38.0);

11240

                                if let Some(v59) = v58 {

11241

                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);

11242

                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);

11243

                                    let v1029 = constructor_x64_addps(ctx, v1013, v1024);

11244

                                    let v1030 = constructor_output_xmm(ctx, v1029);

11245

                                    // Rule at src/isa/x64/lower.isle line 2045.

11246

                                    return Some(v1030);

11247

11248

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11249

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11250

                                let v1020 = constructor_x64_addps(ctx, v68, v69);

11251

                                let v1021 = constructor_output_xmm(ctx, v1020);

11252

                                // Rule at src/isa/x64/lower.isle line 2034.

11253

                                return Some(v1021);

11254

11255

                            F64X2 => {

11256

                                let v38 = C::unpack_value_array_2(ctx, v37);

11257

                                let v58 = &C::sinkable_load(ctx, v38.0);

11258

                                if let Some(v59) = v58 {

11259

                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);

11260

                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);

11261

                                    let v1031 = constructor_x64_addpd(ctx, v1013, v1024);

11262

                                    let v1032 = constructor_output_xmm(ctx, v1031);

11263

                                    // Rule at src/isa/x64/lower.isle line 2047.

11264

                                    return Some(v1032);

11265

11266

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11267

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11268

                                let v1022 = constructor_x64_addpd(ctx, v68, v69);

11269

                                let v1023 = constructor_output_xmm(ctx, v1022);

11270

                                // Rule at src/isa/x64/lower.isle line 2036.

11271

                                return Some(v1023);

11272

11273

                            _ => {}

11274

11275

11276

11277

                &Opcode::Fsub => {

11278

                    let v1 = C::first_result(ctx, arg0);

11279

                    if let Some(v2) = v1 {

11280

                        let v3 = C::value_type(ctx, v2);

11281

                        match v3 {

11282

                            F32 => {

11283

                                let v38 = C::unpack_value_array_2(ctx, v37);

11284

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11285

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11286

                                let v1033 = constructor_x64_subss(ctx, v68, v69);

11287

                                let v1034 = constructor_output_xmm(ctx, v1033);

11288

                                // Rule at src/isa/x64/lower.isle line 2052.

11289

                                return Some(v1034);

11290

11291

                            F64 => {

11292

                                let v38 = C::unpack_value_array_2(ctx, v37);

11293

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11294

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11295

                                let v1035 = constructor_x64_subsd(ctx, v68, v69);

11296

                                let v1036 = constructor_output_xmm(ctx, v1035);

11297

                                // Rule at src/isa/x64/lower.isle line 2054.

11298

                                return Some(v1036);

11299

11300

                            F32X4 => {

11301

                                let v38 = C::unpack_value_array_2(ctx, v37);

11302

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11303

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11304

                                let v1037 = constructor_x64_subps(ctx, v68, v69);

11305

                                let v1038 = constructor_output_xmm(ctx, v1037);

11306

                                // Rule at src/isa/x64/lower.isle line 2056.

11307

                                return Some(v1038);

11308

11309

                            F64X2 => {

11310

                                let v38 = C::unpack_value_array_2(ctx, v37);

11311

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11312

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11313

                                let v1039 = constructor_x64_subpd(ctx, v68, v69);

11314

                                let v1040 = constructor_output_xmm(ctx, v1039);

11315

                                // Rule at src/isa/x64/lower.isle line 2058.

11316

                                return Some(v1040);

11317

11318

                            _ => {}

11319

11320

11321

11322

                &Opcode::Fmul => {

11323

                    let v1 = C::first_result(ctx, arg0);

11324

                    if let Some(v2) = v1 {

11325

                        let v3 = C::value_type(ctx, v2);

11326

                        match v3 {

11327

                            F32 => {

11328

                                let v38 = C::unpack_value_array_2(ctx, v37);

11329

                                let v58 = &C::sinkable_load(ctx, v38.0);

11330

                                if let Some(v59) = v58 {

11331

                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);

11332

                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);

11333

                                    let v1049 = constructor_x64_mulss(ctx, v1013, v1024);

11334

                                    let v1050 = constructor_output_xmm(ctx, v1049);

11335

                                    // Rule at src/isa/x64/lower.isle line 2074.

11336

                                    return Some(v1050);

11337

11338

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11339

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11340

                                let v1041 = constructor_x64_mulss(ctx, v68, v69);

11341

                                let v1042 = constructor_output_xmm(ctx, v1041);

11342

                                // Rule at src/isa/x64/lower.isle line 2063.

11343

                                return Some(v1042);

11344

11345

                            F64 => {

11346

                                let v38 = C::unpack_value_array_2(ctx, v37);

11347

                                let v58 = &C::sinkable_load(ctx, v38.0);

11348

                                if let Some(v59) = v58 {

11349

                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);

11350

                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);

11351

                                    let v1051 = constructor_x64_mulsd(ctx, v1013, v1024);

11352

                                    let v1052 = constructor_output_xmm(ctx, v1051);

11353

                                    // Rule at src/isa/x64/lower.isle line 2076.

11354

                                    return Some(v1052);

11355

11356

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11357

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11358

                                let v1043 = constructor_x64_mulsd(ctx, v68, v69);

11359

                                let v1044 = constructor_output_xmm(ctx, v1043);

11360

                                // Rule at src/isa/x64/lower.isle line 2065.

11361

                                return Some(v1044);

11362

11363

                            F32X4 => {

11364

                                let v38 = C::unpack_value_array_2(ctx, v37);

11365

                                let v58 = &C::sinkable_load(ctx, v38.0);

11366

                                if let Some(v59) = v58 {

11367

                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);

11368

                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);

11369

                                    let v1053 = constructor_x64_mulps(ctx, v1013, v1024);

11370

                                    let v1054 = constructor_output_xmm(ctx, v1053);

11371

                                    // Rule at src/isa/x64/lower.isle line 2078.

11372

                                    return Some(v1054);

11373

11374

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11375

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11376

                                let v1045 = constructor_x64_mulps(ctx, v68, v69);

11377

                                let v1046 = constructor_output_xmm(ctx, v1045);

11378

                                // Rule at src/isa/x64/lower.isle line 2067.

11379

                                return Some(v1046);

11380

11381

                            F64X2 => {

11382

                                let v38 = C::unpack_value_array_2(ctx, v37);

11383

                                let v58 = &C::sinkable_load(ctx, v38.0);

11384

                                if let Some(v59) = v58 {

11385

                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);

11386

                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);

11387

                                    let v1055 = constructor_x64_mulpd(ctx, v1013, v1024);

11388

                                    let v1056 = constructor_output_xmm(ctx, v1055);

11389

                                    // Rule at src/isa/x64/lower.isle line 2080.

11390

                                    return Some(v1056);

11391

11392

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11393

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11394

                                let v1047 = constructor_x64_mulpd(ctx, v68, v69);

11395

                                let v1048 = constructor_output_xmm(ctx, v1047);

11396

                                // Rule at src/isa/x64/lower.isle line 2069.

11397

                                return Some(v1048);

11398

11399

                            _ => {}

11400

11401

11402

11403

                &Opcode::Fdiv => {

11404

                    let v1 = C::first_result(ctx, arg0);

11405

                    if let Some(v2) = v1 {

11406

                        let v3 = C::value_type(ctx, v2);

11407

                        match v3 {

11408

                            F32 => {

11409

                                let v38 = C::unpack_value_array_2(ctx, v37);

11410

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11411

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11412

                                let v1057 = constructor_x64_divss(ctx, v68, v69);

11413

                                let v1058 = constructor_output_xmm(ctx, v1057);

11414

                                // Rule at src/isa/x64/lower.isle line 2085.

11415

                                return Some(v1058);

11416

11417

                            F64 => {

11418

                                let v38 = C::unpack_value_array_2(ctx, v37);

11419

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11420

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11421

                                let v1059 = constructor_x64_divsd(ctx, v68, v69);

11422

                                let v1060 = constructor_output_xmm(ctx, v1059);

11423

                                // Rule at src/isa/x64/lower.isle line 2087.

11424

                                return Some(v1060);

11425

11426

                            F32X4 => {

11427

                                let v38 = C::unpack_value_array_2(ctx, v37);

11428

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11429

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11430

                                let v1061 = constructor_x64_divps(ctx, v68, v69);

11431

                                let v1062 = constructor_output_xmm(ctx, v1061);

11432

                                // Rule at src/isa/x64/lower.isle line 2089.

11433

                                return Some(v1062);

11434

11435

                            F64X2 => {

11436

                                let v38 = C::unpack_value_array_2(ctx, v37);

11437

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11438

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11439

                                let v1063 = constructor_x64_divpd(ctx, v68, v69);

11440

                                let v1064 = constructor_output_xmm(ctx, v1063);

11441

                                // Rule at src/isa/x64/lower.isle line 2091.

11442

                                return Some(v1064);

11443

11444

                            _ => {}

11445

11446

11447

11448

                &Opcode::Fcopysign => {

11449

                    let v1 = C::first_result(ctx, arg0);

11450

                    if let Some(v2) = v1 {

11451

                        let v3 = C::value_type(ctx, v2);

11452

                        match v3 {

11453

                            F32 => {

11454

                                let v38 = C::unpack_value_array_2(ctx, v37);

11455

                                let v1756 = C::value_type(ctx, v38.0);

11456

                                if v1756 == F32 {

11457

                                    let v1798 = constructor_imm(ctx, F32, 0x80000000);

11458

                                    let v1799 = C::xmm_new(ctx, v1798);

11459

                                    let v1800 = &C::put_in_xmm_mem(ctx, v38.0);

11460

                                    let v1801 = constructor_x64_andnps(ctx, v1799, v1800);

11461

                                    let v1802 = &C::put_in_xmm_mem(ctx, v38.1);

11462

                                    let v1803 = constructor_x64_andps(ctx, v1799, v1802);

11463

                                    let v1804 = &C::xmm_to_xmm_mem(ctx, v1803);

11464

                                    let v1805 = constructor_x64_orps(ctx, v1801, v1804);

11465

                                    let v1806 = constructor_output_xmm(ctx, v1805);

11466

                                    // Rule at src/isa/x64/lower.isle line 3275.

11467

                                    return Some(v1806);

11468

11469

11470

                            F64 => {

11471

                                let v38 = C::unpack_value_array_2(ctx, v37);

11472

                                let v1756 = C::value_type(ctx, v38.0);

11473

                                if v1756 == F64 {

11474

                                    let v1807 = constructor_imm(ctx, F64, 0x8000000000000000);

11475

                                    let v1808 = C::xmm_new(ctx, v1807);

11476

                                    let v1800 = &C::put_in_xmm_mem(ctx, v38.0);

11477

                                    let v1809 = constructor_x64_andnpd(ctx, v1808, v1800);

11478

                                    let v1802 = &C::put_in_xmm_mem(ctx, v38.1);

11479

                                    let v1810 = constructor_x64_andpd(ctx, v1808, v1802);

11480

                                    let v1811 = &C::xmm_to_xmm_mem(ctx, v1810);

11481

                                    let v1812 = constructor_x64_orpd(ctx, v1809, v1811);

11482

                                    let v1813 = constructor_output_xmm(ctx, v1812);

11483

                                    // Rule at src/isa/x64/lower.isle line 3281.

11484

                                    return Some(v1813);

11485

11486

11487

                            _ => {}

11488

11489

11490

11491

                &Opcode::Fmin => {

11492

                    let v1 = C::first_result(ctx, arg0);

11493

                    if let Some(v2) = v1 {

11494

                        let v3 = C::value_type(ctx, v2);

11495

                        match v3 {

11496

                            F32 => {

11497

                                let v38 = C::unpack_value_array_2(ctx, v37);

11498

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11499

                                let v366 = constructor_put_in_xmm(ctx, v38.1);

11500

                                let v1083 = constructor_xmm_min_max_seq(ctx, F32, true, v68, v366);

11501

                                let v1084 = constructor_output_xmm(ctx, v1083);

11502

                                // Rule at src/isa/x64/lower.isle line 2122.

11503

                                return Some(v1084);

11504

11505

                            F64 => {

11506

                                let v38 = C::unpack_value_array_2(ctx, v37);

11507

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11508

                                let v366 = constructor_put_in_xmm(ctx, v38.1);

11509

                                let v1085 = constructor_xmm_min_max_seq(ctx, F64, true, v68, v366);

11510

                                let v1086 = constructor_output_xmm(ctx, v1085);

11511

                                // Rule at src/isa/x64/lower.isle line 2124.

11512

                                return Some(v1086);

11513

11514

                            F32X4 => {

11515

                                let v38 = C::unpack_value_array_2(ctx, v37);

11516

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11517

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11518

                                let v1087 = constructor_x64_minps(ctx, v68, v69);

11519

                                let v1088 = constructor_put_in_xmm(ctx, v38.1);

11520

                                let v1089 = &C::put_in_xmm_mem(ctx, v38.0);

11521

                                let v1090 = constructor_x64_minps(ctx, v1088, v1089);

11522

                                let v1091 = &C::xmm_to_xmm_mem(ctx, v1090);

11523

                                let v1092 = constructor_x64_orps(ctx, v1087, v1091);

11524

                                let v1093 = &C::xmm_to_xmm_mem(ctx, v1090);

11525

                                let v1094 =

11526

                                    constructor_x64_cmpps(ctx, v1092, v1093, &FcmpImm::Unordered);

11527

                                let v1095 = &C::xmm_to_xmm_mem(ctx, v1094);

11528

                                let v1096 = constructor_x64_orps(ctx, v1092, v1095);

11529

                                let v1098 = &C::xmi_imm(ctx, 0xA);

11530

                                let v1099 = constructor_x64_psrld(ctx, v1094, v1098);

11531

                                let v1100 = &C::xmm_to_xmm_mem(ctx, v1096);

11532

                                let v1101 = constructor_x64_andnps(ctx, v1099, v1100);

11533

                                let v1102 = constructor_output_xmm(ctx, v1101);

11534

                                // Rule at src/isa/x64/lower.isle line 2139.

11535

                                return Some(v1102);

11536

11537

                            F64X2 => {

11538

                                let v38 = C::unpack_value_array_2(ctx, v37);

11539

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11540

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11541

                                let v1103 = constructor_x64_minpd(ctx, v68, v69);

11542

                                let v1088 = constructor_put_in_xmm(ctx, v38.1);

11543

                                let v1089 = &C::put_in_xmm_mem(ctx, v38.0);

11544

                                let v1104 = constructor_x64_minpd(ctx, v1088, v1089);

11545

                                let v1105 = &C::xmm_to_xmm_mem(ctx, v1104);

11546

                                let v1106 = constructor_x64_orpd(ctx, v1103, v1105);

11547

                                let v1107 = &C::xmm_to_xmm_mem(ctx, v1104);

11548

                                let v1108 =

11549

                                    constructor_x64_cmppd(ctx, v1103, v1107, &FcmpImm::Unordered);

11550

                                let v1109 = &C::xmm_to_xmm_mem(ctx, v1108);

11551

                                let v1110 = constructor_x64_orpd(ctx, v1106, v1109);

11552

                                let v1112 = &C::xmi_imm(ctx, 0xD);

11553

                                let v1113 = constructor_x64_psrlq(ctx, v1108, v1112);

11554

                                let v1114 = &C::xmm_to_xmm_mem(ctx, v1110);

11555

                                let v1115 = constructor_x64_andnpd(ctx, v1113, v1114);

11556

                                let v1116 = constructor_output_xmm(ctx, v1115);

11557

                                // Rule at src/isa/x64/lower.isle line 2182.

11558

                                return Some(v1116);

11559

11560

                            _ => {}

11561

11562

11563

11564

                &Opcode::FminPseudo => {

11565

                    let v1 = C::first_result(ctx, arg0);

11566

                    if let Some(v2) = v1 {

11567

                        let v3 = C::value_type(ctx, v2);

11568

                        match v3 {

11569

                            F32 => {

11570

                                let v38 = C::unpack_value_array_2(ctx, v37);

11571

                                let v1013 = constructor_put_in_xmm(ctx, v38.1);

11572

                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);

11573

                                let v1152 = constructor_x64_minss(ctx, v1013, v160);

11574

                                let v1153 = constructor_output_xmm(ctx, v1152);

11575

                                // Rule at src/isa/x64/lower.isle line 2291.

11576

                                return Some(v1153);

11577

11578

                            F64 => {

11579

                                let v38 = C::unpack_value_array_2(ctx, v37);

11580

                                let v1013 = constructor_put_in_xmm(ctx, v38.1);

11581

                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);

11582

                                let v1154 = constructor_x64_minsd(ctx, v1013, v160);

11583

                                let v1155 = constructor_output_xmm(ctx, v1154);

11584

                                // Rule at src/isa/x64/lower.isle line 2293.

11585

                                return Some(v1155);

11586

11587

                            F32X4 => {

11588

                                let v38 = C::unpack_value_array_2(ctx, v37);

11589

                                let v1013 = constructor_put_in_xmm(ctx, v38.1);

11590

                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);

11591

                                let v1156 = constructor_x64_minps(ctx, v1013, v160);

11592

                                let v1157 = constructor_output_xmm(ctx, v1156);

11593

                                // Rule at src/isa/x64/lower.isle line 2295.

11594

                                return Some(v1157);

11595

11596

                            F64X2 => {

11597

                                let v38 = C::unpack_value_array_2(ctx, v37);

11598

                                let v1013 = constructor_put_in_xmm(ctx, v38.1);

11599

                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);

11600

                                let v1158 = constructor_x64_minpd(ctx, v1013, v160);

11601

                                let v1159 = constructor_output_xmm(ctx, v1158);

11602

                                // Rule at src/isa/x64/lower.isle line 2297.

11603

                                return Some(v1159);

11604

11605

                            _ => {}

11606

11607

11608

11609

                &Opcode::Fmax => {

11610

                    let v1 = C::first_result(ctx, arg0);

11611

                    if let Some(v2) = v1 {

11612

                        let v3 = C::value_type(ctx, v2);

11613

                        match v3 {

11614

                            F32 => {

11615

                                let v38 = C::unpack_value_array_2(ctx, v37);

11616

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11617

                                let v366 = constructor_put_in_xmm(ctx, v38.1);

11618

                                let v1118 = constructor_xmm_min_max_seq(ctx, F32, false, v68, v366);

11619

                                let v1119 = constructor_output_xmm(ctx, v1118);

11620

                                // Rule at src/isa/x64/lower.isle line 2194.

11621

                                return Some(v1119);

11622

11623

                            F64 => {

11624

                                let v38 = C::unpack_value_array_2(ctx, v37);

11625

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11626

                                let v366 = constructor_put_in_xmm(ctx, v38.1);

11627

                                let v1120 = constructor_xmm_min_max_seq(ctx, F64, false, v68, v366);

11628

                                let v1121 = constructor_output_xmm(ctx, v1120);

11629

                                // Rule at src/isa/x64/lower.isle line 2196.

11630

                                return Some(v1121);

11631

11632

                            F32X4 => {

11633

                                let v38 = C::unpack_value_array_2(ctx, v37);

11634

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11635

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11636

                                let v1122 = constructor_x64_maxps(ctx, v68, v69);

11637

                                let v1088 = constructor_put_in_xmm(ctx, v38.1);

11638

                                let v1089 = &C::put_in_xmm_mem(ctx, v38.0);

11639

                                let v1123 = constructor_x64_maxps(ctx, v1088, v1089);

11640

                                let v1124 = &C::xmm_to_xmm_mem(ctx, v1123);

11641

                                let v1125 = constructor_x64_xorps(ctx, v1122, v1124);

11642

                                let v1126 = &C::xmm_to_xmm_mem(ctx, v1125);

11643

                                let v1127 = constructor_x64_orps(ctx, v1122, v1126);

11644

                                let v1128 = &C::xmm_to_xmm_mem(ctx, v1125);

11645

                                let v1129 = constructor_x64_subps(ctx, v1127, v1128);

11646

                                let v1130 = &C::xmm_to_xmm_mem(ctx, v1127);

11647

                                let v1131 =

11648

                                    constructor_x64_cmpps(ctx, v1127, v1130, &FcmpImm::Unordered);

11649

                                let v1132 = &C::xmi_imm(ctx, 0xA);

11650

                                let v1133 = constructor_x64_psrld(ctx, v1131, v1132);

11651

                                let v1134 = &C::xmm_to_xmm_mem(ctx, v1129);

11652

                                let v1135 = constructor_x64_andnps(ctx, v1133, v1134);

11653

                                let v1136 = constructor_output_xmm(ctx, v1135);

11654

                                // Rule at src/isa/x64/lower.isle line 2202.

11655

                                return Some(v1136);

11656

11657

                            F64X2 => {

11658

                                let v38 = C::unpack_value_array_2(ctx, v37);

11659

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

11660

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11661

                                let v1137 = constructor_x64_maxpd(ctx, v68, v69);

11662

                                let v1088 = constructor_put_in_xmm(ctx, v38.1);

11663

                                let v1089 = &C::put_in_xmm_mem(ctx, v38.0);

11664

                                let v1138 = constructor_x64_maxpd(ctx, v1088, v1089);

11665

                                let v1139 = &C::xmm_to_xmm_mem(ctx, v1138);

11666

                                let v1140 = constructor_x64_xorpd(ctx, v1137, v1139);

11667

                                let v1141 = &C::xmm_to_xmm_mem(ctx, v1140);

11668

                                let v1142 = constructor_x64_orpd(ctx, v1137, v1141);

11669

                                let v1143 = &C::xmm_to_xmm_mem(ctx, v1140);

11670

                                let v1144 = constructor_x64_subpd(ctx, v1142, v1143);

11671

                                let v1145 = &C::xmm_to_xmm_mem(ctx, v1142);

11672

                                let v1146 =

11673

                                    constructor_x64_cmppd(ctx, v1142, v1145, &FcmpImm::Unordered);

11674

                                let v1147 = &C::xmi_imm(ctx, 0xD);

11675

                                let v1148 = constructor_x64_psrlq(ctx, v1146, v1147);

11676

                                let v1149 = &C::xmm_to_xmm_mem(ctx, v1144);

11677

                                let v1150 = constructor_x64_andnpd(ctx, v1148, v1149);

11678

                                let v1151 = constructor_output_xmm(ctx, v1150);

11679

                                // Rule at src/isa/x64/lower.isle line 2245.

11680

                                return Some(v1151);

11681

11682

                            _ => {}

11683

11684

11685

11686

                &Opcode::FmaxPseudo => {

11687

                    let v1 = C::first_result(ctx, arg0);

11688

                    if let Some(v2) = v1 {

11689

                        let v3 = C::value_type(ctx, v2);

11690

                        match v3 {

11691

                            F32 => {

11692

                                let v38 = C::unpack_value_array_2(ctx, v37);

11693

                                let v1013 = constructor_put_in_xmm(ctx, v38.1);

11694

                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);

11695

                                let v1160 = constructor_x64_maxss(ctx, v1013, v160);

11696

                                let v1161 = constructor_output_xmm(ctx, v1160);

11697

                                // Rule at src/isa/x64/lower.isle line 2302.

11698

                                return Some(v1161);

11699

11700

                            F64 => {

11701

                                let v38 = C::unpack_value_array_2(ctx, v37);

11702

                                let v1013 = constructor_put_in_xmm(ctx, v38.1);

11703

                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);

11704

                                let v1162 = constructor_x64_maxsd(ctx, v1013, v160);

11705

                                let v1163 = constructor_output_xmm(ctx, v1162);

11706

                                // Rule at src/isa/x64/lower.isle line 2304.

11707

                                return Some(v1163);

11708

11709

                            F32X4 => {

11710

                                let v38 = C::unpack_value_array_2(ctx, v37);

11711

                                let v1013 = constructor_put_in_xmm(ctx, v38.1);

11712

                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);

11713

                                let v1164 = constructor_x64_maxps(ctx, v1013, v160);

11714

                                let v1165 = constructor_output_xmm(ctx, v1164);

11715

                                // Rule at src/isa/x64/lower.isle line 2306.

11716

                                return Some(v1165);

11717

11718

                            F64X2 => {

11719

                                let v38 = C::unpack_value_array_2(ctx, v37);

11720

                                let v1013 = constructor_put_in_xmm(ctx, v38.1);

11721

                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);

11722

                                let v1166 = constructor_x64_maxpd(ctx, v1013, v160);

11723

                                let v1167 = constructor_output_xmm(ctx, v1166);

11724

                                // Rule at src/isa/x64/lower.isle line 2308.

11725

                                return Some(v1167);

11726

11727

                            _ => {}

11728

11729

11730

11731

                &Opcode::Snarrow => {

11732

                    let v1 = C::first_result(ctx, arg0);

11733

                    if let Some(v2) = v1 {

11734

                        let v3 = C::value_type(ctx, v2);

11735

                        match v3 {

11736

                            I8X16 => {

11737

                                let v38 = C::unpack_value_array_2(ctx, v37);

11738

                                let v1756 = C::value_type(ctx, v38.0);

11739

                                if v1756 == I16X8 {

11740

                                    let v68 = constructor_put_in_xmm(ctx, v38.0);

11741

                                    let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11742

                                    let v1757 = constructor_x64_packsswb(ctx, v68, v69);

11743

                                    let v1758 = constructor_output_xmm(ctx, v1757);

11744

                                    // Rule at src/isa/x64/lower.isle line 3202.

11745

                                    return Some(v1758);

11746

11747

11748

                            I16X8 => {

11749

                                let v38 = C::unpack_value_array_2(ctx, v37);

11750

                                let v1756 = C::value_type(ctx, v38.0);

11751

                                if v1756 == I32X4 {

11752

                                    let v68 = constructor_put_in_xmm(ctx, v38.0);

11753

                                    let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11754

                                    let v1759 = constructor_x64_packssdw(ctx, v68, v69);

11755

                                    let v1760 = constructor_output_xmm(ctx, v1759);

11756

                                    // Rule at src/isa/x64/lower.isle line 3205.

11757

                                    return Some(v1760);

11758

11759

11760

                            I32X4 => {

11761

                                let v38 = C::unpack_value_array_2(ctx, v37);

11762

                                let v154 = C::def_inst(ctx, v38.1);

11763

                                if let Some(v155) = v154 {

11764

                                    let v156 = &C::inst_data(ctx, v155);

11765

                                    if let &InstructionData::UnaryConst {

11766

                                        opcode: ref v1764,

11767

                                        constant_handle: v1765,

11768

                                    } = v156

11769

11770

                                        if let &Opcode::Vconst = v1764 {

11771

                                            let v163 = C::def_inst(ctx, v38.0);

11772

                                            if let Some(v164) = v163 {

11773

                                                let v165 = &C::inst_data(ctx, v164);

11774

                                                if let &InstructionData::Unary {

11775

                                                    opcode: ref v166,

11776

                                                    arg: v167,

11777

                                                } = v165

11778

11779

                                                    match v166 {

11780

                                                        &Opcode::FcvtToSintSat => {

11781

                                                            let v1761 = C::first_result(ctx, v164);

11782

                                                            if let Some(v1762) = v1761 {

11783

                                                                let v1763 =

11784

                                                                    C::value_type(ctx, v1762);

11785

                                                                if v1763 == I64X2 {

11786

                                                                    let v1766 =

11787

                                                                        C::u128_from_constant(

11788

                                                                            ctx, v1765,

11789

);

11790

                                                                    if let Some(v1767) = v1766 {

11791

                                                                        if v1767 == 0x0 {

11792

                                                                            let v168 = constructor_put_in_xmm(ctx, v167);

11793

                                                                            let v397 =

11794

                                                                                &C::xmm_to_xmm_mem(

11795

                                                                                    ctx, v168,

11796

);

11797

                                                                            let v1768 = constructor_x64_cmppd(ctx, v168, v397, &FcmpImm::Equal);

11798

                                                                            let v1769 = C::snarrow_umax_mask(ctx);

11799

                                                                            let v1770 = &constructor_const_to_xmm_mem(ctx, v1769);

11800

                                                                            let v1771 = constructor_x64_andps(ctx, v1768, v1770);

11801

                                                                            let v1772 =

11802

                                                                                &C::xmm_to_xmm_mem(

11803

                                                                                    ctx, v1771,

11804

);

11805

                                                                            let v1773 = constructor_x64_minpd(ctx, v168, v1772);

11806

                                                                            let v1774 =

11807

                                                                                &C::xmm_to_xmm_mem(

11808

                                                                                    ctx, v1773,

11809

);

11810

                                                                            let v1775 = constructor_x64_cvttpd2dq(ctx, v1774);

11811

                                                                            let v1776 = constructor_output_xmm(ctx, v1775);

11812

                                                                            // Rule at src/isa/x64/lower.isle line 3214.

11813

                                                                            return Some(v1776);

11814

11815

11816

11817

11818

11819

                                                        &Opcode::X86Cvtt2dq => {

11820

                                                            let v1761 = C::first_result(ctx, v164);

11821

                                                            if let Some(v1762) = v1761 {

11822

                                                                let v1763 =

11823

                                                                    C::value_type(ctx, v1762);

11824

                                                                if v1763 == I64X2 {

11825

                                                                    let v1766 =

11826

                                                                        C::u128_from_constant(

11827

                                                                            ctx, v1765,

11828

);

11829

                                                                    if let Some(v1767) = v1766 {

11830

                                                                        if v1767 == 0x0 {

11831

                                                                            let v418 =

11832

                                                                                &C::put_in_xmm_mem(

11833

                                                                                    ctx, v167,

11834

);

11835

                                                                            let v1777 = constructor_x64_cvttpd2dq(ctx, v418);

11836

                                                                            let v1778 = constructor_output_xmm(ctx, v1777);

11837

                                                                            // Rule at src/isa/x64/lower.isle line 3236.

11838

                                                                            return Some(v1778);

11839

11840

11841

11842

11843

11844

                                                        _ => {}

11845

11846

11847

11848

11849

11850

11851

11852

                            _ => {}

11853

11854

11855

11856

                &Opcode::Unarrow => {

11857

                    let v1 = C::first_result(ctx, arg0);

11858

                    if let Some(v2) = v1 {

11859

                        let v3 = C::value_type(ctx, v2);

11860

                        match v3 {

11861

                            I8X16 => {

11862

                                let v38 = C::unpack_value_array_2(ctx, v37);

11863

                                let v1756 = C::value_type(ctx, v38.0);

11864

                                if v1756 == I16X8 {

11865

                                    let v68 = constructor_put_in_xmm(ctx, v38.0);

11866

                                    let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11867

                                    let v1779 = constructor_x64_packuswb(ctx, v68, v69);

11868

                                    let v1780 = constructor_output_xmm(ctx, v1779);

11869

                                    // Rule at src/isa/x64/lower.isle line 3242.

11870

                                    return Some(v1780);

11871

11872

11873

                            I16X8 => {

11874

                                let v38 = C::unpack_value_array_2(ctx, v37);

11875

                                let v1756 = C::value_type(ctx, v38.0);

11876

                                if v1756 == I32X4 {

11877

                                    let v68 = constructor_put_in_xmm(ctx, v38.0);

11878

                                    let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11879

                                    let v1781 = constructor_x64_packusdw(ctx, v68, v69);

11880

                                    let v1782 = constructor_output_xmm(ctx, v1781);

11881

                                    // Rule at src/isa/x64/lower.isle line 3245.

11882

                                    return Some(v1782);

11883

11884

11885

                            _ => {}

11886

11887

11888

11889

                &Opcode::Uunarrow => {

11890

                    let v38 = C::unpack_value_array_2(ctx, v37);

11891

                    let v154 = C::def_inst(ctx, v38.1);

11892

                    if let Some(v155) = v154 {

11893

                        let v156 = &C::inst_data(ctx, v155);

11894

                        if let &InstructionData::UnaryConst {

11895

                            opcode: ref v1764,

11896

                            constant_handle: v1765,

11897

                        } = v156

11898

11899

                            if let &Opcode::Vconst = v1764 {

11900

                                let v163 = C::def_inst(ctx, v38.0);

11901

                                if let Some(v164) = v163 {

11902

                                    let v165 = &C::inst_data(ctx, v164);

11903

                                    if let &InstructionData::Unary {

11904

                                        opcode: ref v166,

11905

                                        arg: v167,

11906

                                    } = v165

11907

11908

                                        if let &Opcode::FcvtToUintSat = v166 {

11909

                                            let v387 = C::value_type(ctx, v167);

11910

                                            if v387 == F64X2 {

11911

                                                let v1766 = C::u128_from_constant(ctx, v1765);

11912

                                                if let Some(v1767) = v1766 {

11913

                                                    if v1767 == 0x0 {

11914

                                                        let v168 =

11915

                                                            constructor_put_in_xmm(ctx, v167);

11916

                                                        let v2232 =

11917

                                                            constructor_xmm_zero(ctx, F64X2);

11918

                                                        let v2233 = &C::xmm_to_xmm_mem(ctx, v2232);

11919

                                                        let v2234 =

11920

                                                            constructor_x64_maxpd(ctx, v168, v2233);

11921

                                                        let v2235 = C::uunarrow_umax_mask(ctx);

11922

                                                        let v2236 = &constructor_const_to_xmm_mem(

11923

                                                            ctx, v2235,

11924

);

11925

                                                        let v2237 = constructor_x64_minpd(

11926

                                                            ctx, v2234, v2236,

11927

);

11928

                                                        let v2238 = &C::xmm_to_xmm_mem(ctx, v2237);

11929

                                                        let v2239 = constructor_x64_roundpd(

11930

                                                            ctx,

11931

                                                            v2238,

11932

                                                            &RoundImm::RoundZero,

11933

);

11934

                                                        let v2240 = C::uunarrow_uint_mask(ctx);

11935

                                                        let v2241 = &constructor_const_to_xmm_mem(

11936

                                                            ctx, v2240,

11937

);

11938

                                                        let v2242 = constructor_x64_addpd(

11939

                                                            ctx, v2239, v2241,

11940

);

11941

                                                        let v2243 = &C::xmm_to_xmm_mem(ctx, v2232);

11942

                                                        let v2245 = constructor_x64_shufps(

11943

                                                            ctx, v2242, v2243, 0x88,

11944

);

11945

                                                        let v2246 =

11946

                                                            constructor_output_xmm(ctx, v2245);

11947

                                                        // Rule at src/isa/x64/lower.isle line 3957.

11948

                                                        return Some(v2246);

11949

11950

11951

11952

11953

11954

11955

11956

11957

11958

11959

                &Opcode::IaddPairwise => {

11960

                    let v1 = C::first_result(ctx, arg0);

11961

                    if let Some(v2) = v1 {

11962

                        let v3 = C::value_type(ctx, v2);

11963

                        match v3 {

11964

                            I16X8 => {

11965

                                let v38 = C::unpack_value_array_2(ctx, v37);

11966

                                let v154 = C::def_inst(ctx, v38.1);

11967

                                if let Some(v155) = v154 {

11968

                                    let v156 = &C::inst_data(ctx, v155);

11969

                                    if let &InstructionData::Unary {

11970

                                        opcode: ref v157,

11971

                                        arg: v158,

11972

                                    } = v156

11973

11974

                                        match v157 {

11975

                                            &Opcode::SwidenHigh => {

11976

                                                let v163 = C::def_inst(ctx, v38.0);

11977

                                                if let Some(v164) = v163 {

11978

                                                    let v165 = &C::inst_data(ctx, v164);

11979

                                                    if let &InstructionData::Unary {

11980

                                                        opcode: ref v166,

11981

                                                        arg: v167,

11982

                                                    } = v165

11983

11984

                                                        if let &Opcode::SwidenLow = v166 {

11985

                                                            if v158 == v167 {

11986

                                                                let v387 = C::value_type(ctx, v167);

11987

                                                                if v387 == I8X16 {

11988

                                                                    let v1671 = C::iadd_pairwise_mul_const_16(ctx);

11989

                                                                    let v1672 = constructor_x64_xmm_load_const(ctx, I8X16, v1671);

11990

                                                                    let v1673 = &C::put_in_xmm_mem(

11991

                                                                        ctx, v167,

11992

);

11993

                                                                    let v1674 =

11994

                                                                        constructor_x64_pmaddubsw(

11995

                                                                            ctx, v1672, v1673,

11996

);

11997

                                                                    let v1675 =

11998

                                                                        constructor_output_xmm(

11999

                                                                            ctx, v1674,

12000

);

12001

                                                                    // Rule at src/isa/x64/lower.isle line 3108.

12002

                                                                    return Some(v1675);

12003

12004

12005

12006

12007

12008

12009

                                            &Opcode::UwidenHigh => {

12010

                                                let v163 = C::def_inst(ctx, v38.0);

12011

                                                if let Some(v164) = v163 {

12012

                                                    let v165 = &C::inst_data(ctx, v164);

12013

                                                    if let &InstructionData::Unary {

12014

                                                        opcode: ref v166,

12015

                                                        arg: v167,

12016

                                                    } = v165

12017

12018

                                                        if let &Opcode::UwidenLow = v166 {

12019

                                                            if v158 == v167 {

12020

                                                                let v387 = C::value_type(ctx, v167);

12021

                                                                if v387 == I8X16 {

12022

                                                                    let v1671 = C::iadd_pairwise_mul_const_16(ctx);

12023

                                                                    let v1681 = &constructor_const_to_xmm_mem(ctx, v1671);

12024

                                                                    let v1678 =

12025

                                                                        constructor_put_in_xmm(

12026

                                                                            ctx, v167,

12027

);

12028

                                                                    let v1682 =

12029

                                                                        constructor_x64_pmaddubsw(

12030

                                                                            ctx, v1678, v1681,

12031

);

12032

                                                                    let v1683 =

12033

                                                                        constructor_output_xmm(

12034

                                                                            ctx, v1682,

12035

);

12036

                                                                    // Rule at src/isa/x64/lower.isle line 3124.

12037

                                                                    return Some(v1683);

12038

12039

12040

12041

12042

12043

12044

                                            _ => {}

12045

12046

12047

12048

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12049

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12050

                                let v1667 = constructor_x64_phaddw(ctx, v68, v69);

12051

                                let v1668 = constructor_output_xmm(ctx, v1667);

12052

                                // Rule at src/isa/x64/lower.isle line 3101.

12053

                                return Some(v1668);

12054

12055

                            I32X4 => {

12056

                                let v38 = C::unpack_value_array_2(ctx, v37);

12057

                                let v154 = C::def_inst(ctx, v38.1);

12058

                                if let Some(v155) = v154 {

12059

                                    let v156 = &C::inst_data(ctx, v155);

12060

                                    match v156 {

12061

                                        &InstructionData::Binary {

12062

                                            opcode: ref v1709,

12063

                                            args: ref v1710,

12064

                                        } => {

12065

                                            if let &Opcode::Imul = v1709 {

12066

                                                let v163 = C::def_inst(ctx, v38.0);

12067

                                                if let Some(v164) = v163 {

12068

                                                    let v165 = &C::inst_data(ctx, v164);

12069

                                                    if let &InstructionData::Binary {

12070

                                                        opcode: ref v1694,

12071

                                                        args: ref v1695,

12072

                                                    } = v165

12073

12074

                                                        if let &Opcode::Imul = v1694 {

12075

                                                            let v1696 =

12076

                                                                C::unpack_value_array_2(ctx, v1695);

12077

                                                            let v1699 = C::def_inst(ctx, v1696.0);

12078

                                                            if let Some(v1700) = v1699 {

12079

                                                                let v1701 =

12080

                                                                    &C::inst_data(ctx, v1700);

12081

                                                                if let &InstructionData::Unary {

12082

                                                                    opcode: ref v1702,

12083

                                                                    arg: v1703,

12084

                                                                } = v1701

12085

12086

                                                                    if let &Opcode::SwidenLow =

12087

                                                                        v1702

12088

12089

                                                                        let v1704 = C::def_inst(

12090

                                                                            ctx, v1696.1,

12091

);

12092

                                                                        if let Some(v1705) = v1704 {

12093

                                                                            let v1706 =

12094

                                                                                &C::inst_data(

12095

                                                                                    ctx, v1705,

12096

);

12097

                                                                            if let &InstructionData::Unary {

12098

                                                                                opcode: ref v1707,

12099

                                                                                arg: v1708,

12100

                                                                            } = v1706 {

12101

                                                                                if let &Opcode::SwidenLow = v1707 {

12102

                                                                                    let v1711 = C::unpack_value_array_2(ctx, v1710);

12103

                                                                                    let v1714 = C::def_inst(ctx, v1711.0);

12104

                                                                                    if let Some(v1715) = v1714 {

12105

                                                                                        let v1716 = &C::inst_data(ctx, v1715);

12106

                                                                                        if let &InstructionData::Unary {

12107

                                                                                            opcode: ref v1717,

12108

                                                                                            arg: v1718,

12109

                                                                                        } = v1716 {

12110

                                                                                            if let &Opcode::SwidenHigh = v1717 {

12111

                                                                                                if v1703 == v1718 {

12112

                                                                                                    let v1719 = C::def_inst(ctx, v1711.1);

12113

                                                                                                    if let Some(v1720) = v1719 {

12114

                                                                                                        let v1721 = &C::inst_data(ctx, v1720);

12115

                                                                                                        if let &InstructionData::Unary {

12116

                                                                                                            opcode: ref v1722,

12117

                                                                                                            arg: v1723,

12118

                                                                                                        } = v1721 {

12119

                                                                                                            if let &Opcode::SwidenHigh = v1722 {

12120

                                                                                                                if v1708 == v1723 {

12121

                                                                                                                    let v1724 = constructor_put_in_xmm(ctx, v1703);

12122

                                                                                                                    let v1725 = &C::put_in_xmm_mem(ctx, v1708);

12123

                                                                                                                    let v1726 = constructor_x64_pmaddwd(ctx, v1724, v1725);

12124

                                                                                                                    let v1727 = constructor_output_xmm(ctx, v1726);

12125

                                                                                                                    // Rule at src/isa/x64/lower.isle line 3146.

12126

                                                                                                                    return Some(v1727);

12127

12128

12129

12130

12131

12132

12133

12134

12135

12136

12137

12138

12139

12140

12141

12142

12143

12144

12145

12146

                                        &InstructionData::Unary {

12147

                                            opcode: ref v157,

12148

                                            arg: v158,

12149

                                        } => {

12150

                                            match v157 {

12151

                                                &Opcode::SwidenHigh => {

12152

                                                    let v163 = C::def_inst(ctx, v38.0);

12153

                                                    if let Some(v164) = v163 {

12154

                                                        let v165 = &C::inst_data(ctx, v164);

12155

                                                        if let &InstructionData::Unary {

12156

                                                            opcode: ref v166,

12157

                                                            arg: v167,

12158

                                                        } = v165

12159

12160

                                                            if let &Opcode::SwidenLow = v166 {

12161

                                                                if v158 == v167 {

12162

                                                                    let v387 =

12163

                                                                        C::value_type(ctx, v167);

12164

                                                                    if v387 == I16X8 {

12165

                                                                        let v1676 = C::iadd_pairwise_mul_const_32(ctx);

12166

                                                                        let v1677 = &constructor_const_to_xmm_mem(ctx, v1676);

12167

                                                                        let v1678 =

12168

                                                                            constructor_put_in_xmm(

12169

                                                                                ctx, v167,

12170

);

12171

                                                                        let v1679 =

12172

                                                                            constructor_x64_pmaddwd(

12173

                                                                                ctx, v1678, v1677,

12174

);

12175

                                                                        let v1680 =

12176

                                                                            constructor_output_xmm(

12177

                                                                                ctx, v1679,

12178

);

12179

                                                                        // Rule at src/isa/x64/lower.isle line 3116.

12180

                                                                        return Some(v1680);

12181

12182

12183

12184

12185

12186

12187

                                                &Opcode::UwidenHigh => {

12188

                                                    let v163 = C::def_inst(ctx, v38.0);

12189

                                                    if let Some(v164) = v163 {

12190

                                                        let v165 = &C::inst_data(ctx, v164);

12191

                                                        if let &InstructionData::Unary {

12192

                                                            opcode: ref v166,

12193

                                                            arg: v167,

12194

                                                        } = v165

12195

12196

                                                            if let &Opcode::UwidenLow = v166 {

12197

                                                                if v158 == v167 {

12198

                                                                    let v387 =

12199

                                                                        C::value_type(ctx, v167);

12200

                                                                    if v387 == I16X8 {

12201

                                                                        let v1684 = C::iadd_pairwise_xor_const_32(ctx);

12202

                                                                        let v1685 = &constructor_const_to_xmm_mem(ctx, v1684);

12203

                                                                        let v1678 =

12204

                                                                            constructor_put_in_xmm(

12205

                                                                                ctx, v167,

12206

);

12207

                                                                        let v1686 =

12208

                                                                            constructor_x64_pxor(

12209

                                                                                ctx, v1678, v1685,

12210

);

12211

                                                                        let v1687 = C::iadd_pairwise_mul_const_32(ctx);

12212

                                                                        let v1688 = &constructor_const_to_xmm_mem(ctx, v1687);

12213

                                                                        let v1689 =

12214

                                                                            constructor_x64_pmaddwd(

12215

                                                                                ctx, v1686, v1688,

12216

);

12217

                                                                        let v1690 = C::iadd_pairwise_addd_const_32(ctx);

12218

                                                                        let v1691 = &constructor_const_to_xmm_mem(ctx, v1690);

12219

                                                                        let v1692 =

12220

                                                                            constructor_x64_paddd(

12221

                                                                                ctx, v1689, v1691,

12222

);

12223

                                                                        let v1693 =

12224

                                                                            constructor_output_xmm(

12225

                                                                                ctx, v1692,

12226

);

12227

                                                                        // Rule at src/isa/x64/lower.isle line 3132.

12228

                                                                        return Some(v1693);

12229

12230

12231

12232

12233

12234

12235

                                                _ => {}

12236

12237

12238

                                        _ => {}

12239

12240

12241

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12242

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12243

                                let v1669 = constructor_x64_phaddd(ctx, v68, v69);

12244

                                let v1670 = constructor_output_xmm(ctx, v1669);

12245

                                // Rule at src/isa/x64/lower.isle line 3104.

12246

                                return Some(v1670);

12247

12248

                            _ => {}

12249

12250

12251

12252

                &Opcode::X86Pmaddubsw => {

12253

                    let v1 = C::first_result(ctx, arg0);

12254

                    if let Some(v2) = v1 {

12255

                        let v3 = C::value_type(ctx, v2);

12256

                        if v3 == I16X8 {

12257

                            let v38 = C::unpack_value_array_2(ctx, v37);

12258

                            let v1013 = constructor_put_in_xmm(ctx, v38.1);

12259

                            let v160 = &C::put_in_xmm_mem(ctx, v38.0);

12260

                            let v1014 = constructor_x64_pmaddubsw(ctx, v1013, v160);

12261

                            let v1015 = constructor_output_xmm(ctx, v1014);

12262

                            // Rule at src/isa/x64/lower.isle line 2025.

12263

                            return Some(v1015);

12264

12265

12266

12267

                &Opcode::Iconcat => {

12268

                    let v38 = C::unpack_value_array_2(ctx, v37);

12269

                    let v1756 = C::value_type(ctx, v38.0);

12270

                    if v1756 == I64 {

12271

                        let v2207 = C::put_in_reg(ctx, v38.0);

12272

                        let v2208 = C::put_in_reg(ctx, v38.1);

12273

                        let v2209 = C::value_regs(ctx, v2207, v2208);

12274

                        let v2210 = C::output(ctx, v2209);

12275

                        // Rule at src/isa/x64/lower.isle line 3905.

12276

                        return Some(v2210);

12277

12278

12279

                _ => {}

12280

12281

12282

        &InstructionData::BinaryImm8 {

12283

            opcode: ref v2081,

12284

            arg: v2082,

12285

            imm: v2083,

12286

        } => {

12287

            if let &Opcode::Extractlane = v2081 {

12288

                let v1 = C::first_result(ctx, arg0);

12289

                if let Some(v2) = v1 {

12290

                    let v2084 = C::u8_from_uimm8(ctx, v2083);

12291

                    match v2084 {

12292

                        0x0 => {

12293

                            let v3 = C::value_type(ctx, v2);

12294

                            let v144 = C::ty_scalar_float(ctx, v3);

12295

                            if let Some(v145) = v144 {

12296

                                let v2085 = constructor_output_value(ctx, v2082);

12297

                                // Rule at src/isa/x64/lower.isle line 3716.

12298

                                return Some(v2085);

12299

12300

12301

                        0x1 => {

12302

                            let v3 = C::value_type(ctx, v2);

12303

                            if v3 == F64 {

12304

                                let v2086 = C::value_type(ctx, v2082);

12305

                                let v2087 = C::ty_vec128(ctx, v2086);

12306

                                if let Some(v2088) = v2087 {

12307

                                    let v2089 = &C::put_in_xmm_mem(ctx, v2082);

12308

                                    let v2092 = constructor_x64_pshufd(ctx, v2089, 0xEE);

12309

                                    let v2093 = constructor_output_xmm(ctx, v2092);

12310

                                    // Rule at src/isa/x64/lower.isle line 3725.

12311

                                    return Some(v2093);

12312

12313

12314

12315

                        _ => {}

12316

12317

                    let v3 = C::value_type(ctx, v2);

12318

                    if v3 == F32 {

12319

                        let v2086 = C::value_type(ctx, v2082);

12320

                        let v2087 = C::ty_vec128(ctx, v2086);

12321

                        if let Some(v2088) = v2087 {

12322

                            let v2089 = &C::put_in_xmm_mem(ctx, v2082);

12323

                            let v2090 = constructor_x64_pshufd(ctx, v2089, v2084);

12324

                            let v2091 = constructor_output_xmm(ctx, v2090);

12325

                            // Rule at src/isa/x64/lower.isle line 3720.

12326

                            return Some(v2091);

12327

12328

12329

12330

                let v2086 = C::value_type(ctx, v2082);

12331

                let v2094 = C::multi_lane(ctx, v2086);

12332

                if let Some(v2095) = v2094 {

12333

                    match v2095.0 {

12334

                        0x8 => {

12335

                            if v2095.1 == 0x10 {

12336

                                let v2098 = constructor_put_in_xmm(ctx, v2082);

12337

                                let v2084 = C::u8_from_uimm8(ctx, v2083);

12338

                                let v2099 = constructor_x64_pextrb(ctx, v2098, v2084);

12339

                                let v2100 = constructor_output_gpr(ctx, v2099);

12340

                                // Rule at src/isa/x64/lower.isle line 3734.

12341

                                return Some(v2100);

12342

12343

12344

                        0x10 => {

12345

                            if v2095.1 == 0x8 {

12346

                                let v2098 = constructor_put_in_xmm(ctx, v2082);

12347

                                let v2084 = C::u8_from_uimm8(ctx, v2083);

12348

                                let v2101 = constructor_x64_pextrw(ctx, v2098, v2084);

12349

                                let v2102 = constructor_output_gpr(ctx, v2101);

12350

                                // Rule at src/isa/x64/lower.isle line 3739.

12351

                                return Some(v2102);

12352

12353

12354

                        0x20 => {

12355

                            if v2095.1 == 0x4 {

12356

                                let v2098 = constructor_put_in_xmm(ctx, v2082);

12357

                                let v2084 = C::u8_from_uimm8(ctx, v2083);

12358

                                let v2103 = constructor_x64_pextrd(ctx, v2098, v2084);

12359

                                let v2104 = constructor_output_gpr(ctx, v2103);

12360

                                // Rule at src/isa/x64/lower.isle line 3744.

12361

                                return Some(v2104);

12362

12363

12364

                        0x40 => {

12365

                            if v2095.1 == 0x2 {

12366

                                let v2098 = constructor_put_in_xmm(ctx, v2082);

12367

                                let v2084 = C::u8_from_uimm8(ctx, v2083);

12368

                                let v2105 = constructor_x64_pextrq(ctx, v2098, v2084);

12369

                                let v2106 = constructor_output_gpr(ctx, v2105);

12370

                                // Rule at src/isa/x64/lower.isle line 3747.

12371

                                return Some(v2106);

12372

12373

12374

                        _ => {}

12375

12376

12377

12378

12379

        &InstructionData::Call {

12380

            opcode: ref v1515,

12381

            args: v1516,

12382

            func_ref: v1517,

12383

        } => {

12384

            if let &Opcode::Call = v1515 {

12385

                let v1519 = C::func_ref_data(ctx, v1517);

12386

                let v1518 = C::value_list_slice(ctx, v1516);

12387

                let v1523 = C::gen_call(ctx, v1519.0, v1519.1, v1519.2, v1518);

12388

                // Rule at src/isa/x64/lower.isle line 2771.

12389

                return Some(v1523);

12390

12391

12392

        &InstructionData::CallIndirect {

12393

            opcode: ref v1524,

12394

            args: v1525,

12395

            sig_ref: v1526,

12396

        } => {

12397

            if let &Opcode::CallIndirect = v1524 {

12398

                let v1527 = C::value_list_slice(ctx, v1525);

12399

                let v1528 = C::value_slice_unwrap(ctx, v1527);

12400

                if let Some(v1529) = v1528 {

12401

                    let v1532 = C::gen_call_indirect(ctx, v1526, v1529.0, v1529.1);

12402

                    // Rule at src/isa/x64/lower.isle line 2774.

12403

                    return Some(v1532);

12404

12405

12406

12407

        &InstructionData::FloatCompare {

12408

            opcode: ref v759,

12409

            args: ref v760,

12410

            cond: ref v761,

12411

        } => {

12412

            if let &Opcode::Fcmp = v759 {

12413

                match v761 {

12414

                    &FloatCC::Equal => {

12415

                        let v762 = C::unpack_value_array_2(ctx, v760);

12416

                        let v765 = C::value_type(ctx, v762.0);

12417

                        let v771 = C::ty_vec128(ctx, v765);

12418

                        if let Some(v772) = v771 {

12419

                            let v773 = constructor_put_in_xmm(ctx, v762.0);

12420

                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);

12421

                            let v776 = constructor_x64_cmpp(ctx, v772, v773, v774, &FcmpImm::Equal);

12422

                            let v777 = constructor_output_xmm(ctx, v776);

12423

                            // Rule at src/isa/x64/lower.isle line 1538.

12424

                            return Some(v777);

12425

12426

12427

                    &FloatCC::GreaterThan => {

12428

                        let v762 = C::unpack_value_array_2(ctx, v760);

12429

                        let v765 = C::value_type(ctx, v762.0);

12430

                        let v771 = C::ty_vec128(ctx, v765);

12431

                        if let Some(v772) = v771 {

12432

                            let v799 = constructor_put_in_xmm(ctx, v762.1);

12433

                            let v800 = &C::put_in_xmm_mem(ctx, v762.0);

12434

                            let v801 =

12435

                                constructor_x64_cmpp(ctx, v772, v799, v800, &FcmpImm::LessThan);

12436

                            let v802 = constructor_output_xmm(ctx, v801);

12437

                            // Rule at src/isa/x64/lower.isle line 1558.

12438

                            return Some(v802);

12439

12440

12441

                    &FloatCC::GreaterThanOrEqual => {

12442

                        let v762 = C::unpack_value_array_2(ctx, v760);

12443

                        let v765 = C::value_type(ctx, v762.0);

12444

                        let v771 = C::ty_vec128(ctx, v765);

12445

                        if let Some(v772) = v771 {

12446

                            let v799 = constructor_put_in_xmm(ctx, v762.1);

12447

                            let v800 = &C::put_in_xmm_mem(ctx, v762.0);

12448

                            let v803 = constructor_x64_cmpp(

12449

                                ctx,

12450

                                v772,

12451

                                v799,

12452

                                v800,

12453

                                &FcmpImm::LessThanOrEqual,

12454

);

12455

                            let v804 = constructor_output_xmm(ctx, v803);

12456

                            // Rule at src/isa/x64/lower.isle line 1560.

12457

                            return Some(v804);

12458

12459

12460

                    &FloatCC::LessThan => {

12461

                        let v762 = C::unpack_value_array_2(ctx, v760);

12462

                        let v765 = C::value_type(ctx, v762.0);

12463

                        let v771 = C::ty_vec128(ctx, v765);

12464

                        if let Some(v772) = v771 {

12465

                            let v773 = constructor_put_in_xmm(ctx, v762.0);

12466

                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);

12467

                            let v782 =

12468

                                constructor_x64_cmpp(ctx, v772, v773, v774, &FcmpImm::LessThan);

12469

                            let v783 = constructor_output_xmm(ctx, v782);

12470

                            // Rule at src/isa/x64/lower.isle line 1542.

12471

                            return Some(v783);

12472

12473

12474

                    &FloatCC::LessThanOrEqual => {

12475

                        let v762 = C::unpack_value_array_2(ctx, v760);

12476

                        let v765 = C::value_type(ctx, v762.0);

12477

                        let v771 = C::ty_vec128(ctx, v765);

12478

                        if let Some(v772) = v771 {

12479

                            let v773 = constructor_put_in_xmm(ctx, v762.0);

12480

                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);

12481

                            let v785 = constructor_x64_cmpp(

12482

                                ctx,

12483

                                v772,

12484

                                v773,

12485

                                v774,

12486

                                &FcmpImm::LessThanOrEqual,

12487

);

12488

                            let v786 = constructor_output_xmm(ctx, v785);

12489

                            // Rule at src/isa/x64/lower.isle line 1544.

12490

                            return Some(v786);

12491

12492

12493

                    &FloatCC::NotEqual => {

12494

                        let v762 = C::unpack_value_array_2(ctx, v760);

12495

                        let v765 = C::value_type(ctx, v762.0);

12496

                        let v771 = C::ty_vec128(ctx, v765);

12497

                        if let Some(v772) = v771 {

12498

                            let v773 = constructor_put_in_xmm(ctx, v762.0);

12499

                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);

12500

                            let v779 =

12501

                                constructor_x64_cmpp(ctx, v772, v773, v774, &FcmpImm::NotEqual);

12502

                            let v780 = constructor_output_xmm(ctx, v779);

12503

                            // Rule at src/isa/x64/lower.isle line 1540.

12504

                            return Some(v780);

12505

12506

12507

                    &FloatCC::Ordered => {

12508

                        let v762 = C::unpack_value_array_2(ctx, v760);

12509

                        let v765 = C::value_type(ctx, v762.0);

12510

                        let v771 = C::ty_vec128(ctx, v765);

12511

                        if let Some(v772) = v771 {

12512

                            let v773 = constructor_put_in_xmm(ctx, v762.0);

12513

                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);

12514

                            let v788 =

12515

                                constructor_x64_cmpp(ctx, v772, v773, v774, &FcmpImm::Ordered);

12516

                            let v789 = constructor_output_xmm(ctx, v788);

12517

                            // Rule at src/isa/x64/lower.isle line 1546.

12518

                            return Some(v789);

12519

12520

12521

                    &FloatCC::Unordered => {

12522

                        let v762 = C::unpack_value_array_2(ctx, v760);

12523

                        let v765 = C::value_type(ctx, v762.0);

12524

                        let v771 = C::ty_vec128(ctx, v765);

12525

                        if let Some(v772) = v771 {

12526

                            let v773 = constructor_put_in_xmm(ctx, v762.0);

12527

                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);

12528

                            let v791 =

12529

                                constructor_x64_cmpp(ctx, v772, v773, v774, &FcmpImm::Unordered);

12530

                            let v792 = constructor_output_xmm(ctx, v791);

12531

                            // Rule at src/isa/x64/lower.isle line 1548.

12532

                            return Some(v792);

12533

12534

12535

                    &FloatCC::UnorderedOrGreaterThan => {

12536

                        let v762 = C::unpack_value_array_2(ctx, v760);

12537

                        let v765 = C::value_type(ctx, v762.0);

12538

                        let v771 = C::ty_vec128(ctx, v765);

12539

                        if let Some(v772) = v771 {

12540

                            let v773 = constructor_put_in_xmm(ctx, v762.0);

12541

                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);

12542

                            let v794 = constructor_x64_cmpp(

12543

                                ctx,

12544

                                v772,

12545

                                v773,

12546

                                v774,

12547

                                &FcmpImm::UnorderedOrGreaterThan,

12548

);

12549

                            let v795 = constructor_output_xmm(ctx, v794);

12550

                            // Rule at src/isa/x64/lower.isle line 1550.

12551

                            return Some(v795);

12552

12553

12554

                    &FloatCC::UnorderedOrGreaterThanOrEqual => {

12555

                        let v762 = C::unpack_value_array_2(ctx, v760);

12556

                        let v765 = C::value_type(ctx, v762.0);

12557

                        let v771 = C::ty_vec128(ctx, v765);

12558

                        if let Some(v772) = v771 {

12559

                            let v773 = constructor_put_in_xmm(ctx, v762.0);

12560

                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);

12561

                            let v797 = constructor_x64_cmpp(

12562

                                ctx,

12563

                                v772,

12564

                                v773,

12565

                                v774,

12566

                                &FcmpImm::UnorderedOrGreaterThanOrEqual,

12567

);

12568

                            let v798 = constructor_output_xmm(ctx, v797);

12569

                            // Rule at src/isa/x64/lower.isle line 1552.

12570

                            return Some(v798);

12571

12572

12573

                    &FloatCC::UnorderedOrLessThan => {

12574

                        let v762 = C::unpack_value_array_2(ctx, v760);

12575

                        let v765 = C::value_type(ctx, v762.0);

12576

                        let v771 = C::ty_vec128(ctx, v765);

12577

                        if let Some(v772) = v771 {

12578

                            let v799 = constructor_put_in_xmm(ctx, v762.1);

12579

                            let v800 = &C::put_in_xmm_mem(ctx, v762.0);

12580

                            let v805 = constructor_x64_cmpp(

12581

                                ctx,

12582

                                v772,

12583

                                v799,

12584

                                v800,

12585

                                &FcmpImm::UnorderedOrGreaterThan,

12586

);

12587

                            let v806 = constructor_output_xmm(ctx, v805);

12588

                            // Rule at src/isa/x64/lower.isle line 1562.

12589

                            return Some(v806);

12590

12591

12592

                    &FloatCC::UnorderedOrLessThanOrEqual => {

12593

                        let v762 = C::unpack_value_array_2(ctx, v760);

12594

                        let v765 = C::value_type(ctx, v762.0);

12595

                        let v771 = C::ty_vec128(ctx, v765);

12596

                        if let Some(v772) = v771 {

12597

                            let v799 = constructor_put_in_xmm(ctx, v762.1);

12598

                            let v800 = &C::put_in_xmm_mem(ctx, v762.0);

12599

                            let v807 = constructor_x64_cmpp(

12600

                                ctx,

12601

                                v772,

12602

                                v799,

12603

                                v800,

12604

                                &FcmpImm::UnorderedOrGreaterThanOrEqual,

12605

);

12606

                            let v808 = constructor_output_xmm(ctx, v807);

12607

                            // Rule at src/isa/x64/lower.isle line 1564.

12608

                            return Some(v808);

12609

12610

12611

                    _ => {}

12612

12613

                let v762 = C::unpack_value_array_2(ctx, v760);

12614

                let v765 = C::value_type(ctx, v762.0);

12615

                let v766 = C::ty_scalar_float(ctx, v765);

12616

                if let Some(v767) = v766 {

12617

                    let v768 = &constructor_emit_fcmp(ctx, v761, v762.0, v762.1);

12618

                    let v769 = constructor_lower_fcmp_bool(ctx, v768);

12619

                    let v770 = C::output(ctx, v769);

12620

                    // Rule at src/isa/x64/lower.isle line 1531.

12621

                    return Some(v770);

12622

12623

12624

12625

        &InstructionData::FuncAddr {

12626

            opcode: ref v1439,

12627

            func_ref: v1440,

12628

        } => {

12629

            if let &Opcode::FuncAddr = v1439 {

12630

                let v1441 = C::func_ref_data(ctx, v1440);

12631

                let v1446 = constructor_load_ext_name(ctx, v1441.1, 0x0);

12632

                let v1447 = constructor_output_reg(ctx, v1446);

12633

                // Rule at src/isa/x64/lower.isle line 2713.

12634

                return Some(v1447);

12635

12636

12637

        &InstructionData::IntAddTrap {

12638

            opcode: ref v622,

12639

            args: ref v623,

12640

            code: ref v624,

12641

        } => {

12642

            if let &Opcode::UaddOverflowTrap = v622 {

12643

                let v1 = C::first_result(ctx, arg0);

12644

                if let Some(v2) = v1 {

12645

                    let v3 = C::value_type(ctx, v2);

12646

                    let v4 = C::fits_in_64(ctx, v3);

12647

                    if let Some(v5) = v4 {

12648

                        let v625 = C::unpack_value_array_2(ctx, v623);

12649

                        let v641 = &C::sinkable_load(ctx, v625.0);

12650

                        if let Some(v642) = v641 {

12651

                            let v636 = constructor_put_in_gpr(ctx, v625.1);

12652

                            let v643 = &constructor_sink_load_to_gpr_mem_imm(ctx, v642);

12653

                            let v644 = &constructor_x64_add_with_flags_paired(ctx, v5, v636, v643);

12654

                            let v631 = &constructor_trap_if(ctx, &CC::B, v624);

12655

                            let v645 = constructor_with_flags(ctx, v644, v631);

12656

                            let v646 = C::output(ctx, v645);

12657

                            // Rule at src/isa/x64/lower.isle line 1384.

12658

                            return Some(v646);

12659

12660

                        let v634 = &C::simm32_from_value(ctx, v625.0);

12661

                        if let Some(v635) = v634 {

12662

                            let v636 = constructor_put_in_gpr(ctx, v625.1);

12663

                            let v637 = &constructor_x64_add_with_flags_paired(ctx, v5, v636, v635);

12664

                            let v638 = &constructor_trap_if(ctx, &CC::B, v624);

12665

                            let v639 = constructor_with_flags(ctx, v637, v638);

12666

                            let v640 = C::output(ctx, v639);

12667

                            // Rule at src/isa/x64/lower.isle line 1378.

12668

                            return Some(v640);

12669

12670

                        let v628 = constructor_put_in_gpr(ctx, v625.0);

12671

                        let v629 = &constructor_put_in_gpr_mem_imm(ctx, v625.1);

12672

                        let v630 = &constructor_x64_add_with_flags_paired(ctx, v5, v628, v629);

12673

                        let v631 = &constructor_trap_if(ctx, &CC::B, v624);

12674

                        let v632 = constructor_with_flags(ctx, v630, v631);

12675

                        let v633 = C::output(ctx, v632);

12676

                        // Rule at src/isa/x64/lower.isle line 1370.

12677

                        return Some(v633);

12678

12679

12680

12681

12682

        &InstructionData::IntCompare {

12683

            opcode: ref v653,

12684

            args: ref v654,

12685

            cond: ref v655,

12686

        } => {

12687

            if let &Opcode::Icmp = v653 {

12688

                match v655 {

12689

                    &IntCC::Equal => {

12690

                        let v656 = C::unpack_value_array_2(ctx, v654);

12691

                        let v659 = C::value_type(ctx, v656.0);

12692

                        let v707 = C::ty_vec128(ctx, v659);

12693

                        if let Some(v708) = v707 {

12694

                            let v709 = constructor_put_in_xmm(ctx, v656.0);

12695

                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);

12696

                            let v711 = constructor_x64_pcmpeq(ctx, v708, v709, v710);

12697

                            let v712 = constructor_output_xmm(ctx, v711);

12698

                            // Rule at src/isa/x64/lower.isle line 1446.

12699

                            return Some(v712);

12700

12701

12702

                    &IntCC::NotEqual => {

12703

                        let v656 = C::unpack_value_array_2(ctx, v654);

12704

                        let v659 = C::value_type(ctx, v656.0);

12705

                        let v707 = C::ty_vec128(ctx, v659);

12706

                        if let Some(v708) = v707 {

12707

                            let v709 = constructor_put_in_xmm(ctx, v656.0);

12708

                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);

12709

                            let v711 = constructor_x64_pcmpeq(ctx, v708, v709, v710);

12710

                            let v713 = constructor_vector_all_ones(ctx);

12711

                            let v714 = &C::xmm_to_xmm_mem(ctx, v713);

12712

                            let v715 = constructor_x64_pxor(ctx, v711, v714);

12713

                            let v716 = constructor_output_xmm(ctx, v715);

12714

                            // Rule at src/isa/x64/lower.isle line 1451.

12715

                            return Some(v716);

12716

12717

12718

                    &IntCC::SignedGreaterThan => {

12719

                        let v1 = C::first_result(ctx, arg0);

12720

                        if let Some(v2) = v1 {

12721

                            let v3 = C::value_type(ctx, v2);

12722

                            if v3 == I8 {

12723

                                let v656 = C::unpack_value_array_2(ctx, v654);

12724

                                let v677 = C::def_inst(ctx, v656.0);

12725

                                if let Some(v678) = v677 {

12726

                                    let v679 = &C::inst_data(ctx, v678);

12727

                                    if let &InstructionData::UnaryImm {

12728

                                        opcode: ref v680,

12729

                                        imm: v681,

12730

                                    } = v679

12731

12732

                                        if let &Opcode::Iconst = v680 {

12733

                                            let v682 = C::u64_from_imm64(ctx, v681);

12734

                                            if v682 == 0x0 {

12735

                                                let v683 = C::value_type(ctx, v656.1);

12736

                                                match v683 {

12737

                                                    I32 => {

12738

                                                        let v684 =

12739

                                                            constructor_put_in_gpr(ctx, v656.1);

12740

                                                        let v696 = Imm8Reg::Imm8 { imm: 0x1F };

12741

                                                        let v697 =

12742

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v696);

12743

                                                        let v700 = constructor_x64_shr(

12744

                                                            ctx, I32, v684, v697,

12745

);

12746

                                                        let v701 =

12747

                                                            constructor_output_gpr(ctx, v700);

12748

                                                        // Rule at src/isa/x64/lower.isle line 1430.

12749

                                                        return Some(v701);

12750

12751

                                                    I64 => {

12752

                                                        let v684 =

12753

                                                            constructor_put_in_gpr(ctx, v656.1);

12754

                                                        let v673 = Imm8Reg::Imm8 { imm: 0x3F };

12755

                                                        let v674 =

12756

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v673);

12757

                                                        let v685 = constructor_x64_shr(

12758

                                                            ctx, I64, v684, v674,

12759

);

12760

                                                        let v686 =

12761

                                                            constructor_output_gpr(ctx, v685);

12762

                                                        // Rule at src/isa/x64/lower.isle line 1414.

12763

                                                        return Some(v686);

12764

12765

                                                    _ => {}

12766

12767

12768

12769

12770

12771

12772

12773

                        let v656 = C::unpack_value_array_2(ctx, v654);

12774

                        let v659 = C::value_type(ctx, v656.0);

12775

                        let v707 = C::ty_vec128(ctx, v659);

12776

                        if let Some(v708) = v707 {

12777

                            let v709 = constructor_put_in_xmm(ctx, v656.0);

12778

                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);

12779

                            let v717 = constructor_x64_pcmpgt(ctx, v708, v709, v710);

12780

                            let v718 = constructor_output_xmm(ctx, v717);

12781

                            // Rule at src/isa/x64/lower.isle line 1458.

12782

                            return Some(v718);

12783

12784

12785

                    &IntCC::SignedGreaterThanOrEqual => {

12786

                        let v656 = C::unpack_value_array_2(ctx, v654);

12787

                        let v659 = C::value_type(ctx, v656.0);

12788

                        match v659 {

12789

                            I32 => {

12790

                                let v1 = C::first_result(ctx, arg0);

12791

                                if let Some(v2) = v1 {

12792

                                    let v3 = C::value_type(ctx, v2);

12793

                                    if v3 == I8 {

12794

                                        let v665 = C::def_inst(ctx, v656.1);

12795

                                        if let Some(v666) = v665 {

12796

                                            let v667 = &C::inst_data(ctx, v666);

12797

                                            if let &InstructionData::UnaryImm {

12798

                                                opcode: ref v668,

12799

                                                imm: v669,

12800

                                            } = v667

12801

12802

                                                if let &Opcode::Iconst = v668 {

12803

                                                    let v670 = C::u64_from_imm64(ctx, v669);

12804

                                                    if v670 == 0x0 {

12805

                                                        let v671 =

12806

                                                            constructor_put_in_gpr(ctx, v656.0);

12807

                                                        let v691 =

12808

                                                            constructor_x64_not(ctx, I64, v671);

12809

                                                        let v696 = Imm8Reg::Imm8 { imm: 0x1F };

12810

                                                        let v702 =

12811

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v696);

12812

                                                        let v705 = constructor_x64_shr(

12813

                                                            ctx, I32, v691, v702,

12814

);

12815

                                                        let v706 =

12816

                                                            constructor_output_gpr(ctx, v705);

12817

                                                        // Rule at src/isa/x64/lower.isle line 1438.

12818

                                                        return Some(v706);

12819

12820

12821

12822

12823

12824

12825

12826

                            I64 => {

12827

                                let v1 = C::first_result(ctx, arg0);

12828

                                if let Some(v2) = v1 {

12829

                                    let v3 = C::value_type(ctx, v2);

12830

                                    if v3 == I8 {

12831

                                        let v665 = C::def_inst(ctx, v656.1);

12832

                                        if let Some(v666) = v665 {

12833

                                            let v667 = &C::inst_data(ctx, v666);

12834

                                            if let &InstructionData::UnaryImm {

12835

                                                opcode: ref v668,

12836

                                                imm: v669,

12837

                                            } = v667

12838

12839

                                                if let &Opcode::Iconst = v668 {

12840

                                                    let v670 = C::u64_from_imm64(ctx, v669);

12841

                                                    if v670 == 0x0 {

12842

                                                        let v671 =

12843

                                                            constructor_put_in_gpr(ctx, v656.0);

12844

                                                        let v691 =

12845

                                                            constructor_x64_not(ctx, I64, v671);

12846

                                                        let v673 = Imm8Reg::Imm8 { imm: 0x3F };

12847

                                                        let v688 =

12848

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v673);

12849

                                                        let v692 = constructor_x64_shr(

12850

                                                            ctx, I64, v691, v688,

12851

);

12852

                                                        let v693 =

12853

                                                            constructor_output_gpr(ctx, v692);

12854

                                                        // Rule at src/isa/x64/lower.isle line 1422.

12855

                                                        return Some(v693);

12856

12857

12858

12859

12860

12861

12862

12863

                            I64X2 => {

12864

                                let v719 = constructor_put_in_xmm(ctx, v656.1);

12865

                                let v720 = &C::put_in_xmm_mem(ctx, v656.0);

12866

                                let v753 = constructor_x64_pcmpgt(ctx, I64X2, v719, v720);

12867

                                let v713 = constructor_vector_all_ones(ctx);

12868

                                let v714 = &C::xmm_to_xmm_mem(ctx, v713);

12869

                                let v754 = constructor_x64_pxor(ctx, v753, v714);

12870

                                let v755 = constructor_output_xmm(ctx, v754);

12871

                                // Rule at src/isa/x64/lower.isle line 1498.

12872

                                return Some(v755);

12873

12874

                            _ => {}

12875

12876

                        let v707 = C::ty_vec128(ctx, v659);

12877

                        if let Some(v708) = v707 {

12878

                            let v709 = constructor_put_in_xmm(ctx, v656.0);

12879

                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);

12880

                            let v736 = constructor_x64_pmaxs(ctx, v708, v709, v710);

12881

                            let v737 = constructor_put_in_xmm(ctx, v656.0);

12882

                            let v738 = &C::xmm_to_xmm_mem(ctx, v736);

12883

                            let v739 = constructor_x64_pcmpeq(ctx, v708, v737, v738);

12884

                            let v740 = constructor_output_xmm(ctx, v739);

12885

                            // Rule at src/isa/x64/lower.isle line 1483.

12886

                            return Some(v740);

12887

12888

12889

                    &IntCC::SignedLessThan => {

12890

                        let v1 = C::first_result(ctx, arg0);

12891

                        if let Some(v2) = v1 {

12892

                            let v3 = C::value_type(ctx, v2);

12893

                            if v3 == I8 {

12894

                                let v656 = C::unpack_value_array_2(ctx, v654);

12895

                                let v659 = C::value_type(ctx, v656.0);

12896

                                match v659 {

12897

                                    I32 => {

12898

                                        let v665 = C::def_inst(ctx, v656.1);

12899

                                        if let Some(v666) = v665 {

12900

                                            let v667 = &C::inst_data(ctx, v666);

12901

                                            if let &InstructionData::UnaryImm {

12902

                                                opcode: ref v668,

12903

                                                imm: v669,

12904

                                            } = v667

12905

12906

                                                if let &Opcode::Iconst = v668 {

12907

                                                    let v670 = C::u64_from_imm64(ctx, v669);

12908

                                                    if v670 == 0x0 {

12909

                                                        let v671 =

12910

                                                            constructor_put_in_gpr(ctx, v656.0);

12911

                                                        let v696 = Imm8Reg::Imm8 { imm: 0x1F };

12912

                                                        let v697 =

12913

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v696);

12914

                                                        let v698 = constructor_x64_shr(

12915

                                                            ctx, I32, v671, v697,

12916

);

12917

                                                        let v699 =

12918

                                                            constructor_output_gpr(ctx, v698);

12919

                                                        // Rule at src/isa/x64/lower.isle line 1426.

12920

                                                        return Some(v699);

12921

12922

12923

12924

12925

12926

                                    I64 => {

12927

                                        let v665 = C::def_inst(ctx, v656.1);

12928

                                        if let Some(v666) = v665 {

12929

                                            let v667 = &C::inst_data(ctx, v666);

12930

                                            if let &InstructionData::UnaryImm {

12931

                                                opcode: ref v668,

12932

                                                imm: v669,

12933

                                            } = v667

12934

12935

                                                if let &Opcode::Iconst = v668 {

12936

                                                    let v670 = C::u64_from_imm64(ctx, v669);

12937

                                                    if v670 == 0x0 {

12938

                                                        let v671 =

12939

                                                            constructor_put_in_gpr(ctx, v656.0);

12940

                                                        let v673 = Imm8Reg::Imm8 { imm: 0x3F };

12941

                                                        let v674 =

12942

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v673);

12943

                                                        let v675 = constructor_x64_shr(

12944

                                                            ctx, I64, v671, v674,

12945

);

12946

                                                        let v676 =

12947

                                                            constructor_output_gpr(ctx, v675);

12948

                                                        // Rule at src/isa/x64/lower.isle line 1410.

12949

                                                        return Some(v676);

12950

12951

12952

12953

12954

12955

                                    _ => {}

12956

12957

12958

12959

                        let v656 = C::unpack_value_array_2(ctx, v654);

12960

                        let v659 = C::value_type(ctx, v656.0);

12961

                        let v707 = C::ty_vec128(ctx, v659);

12962

                        if let Some(v708) = v707 {

12963

                            let v719 = constructor_put_in_xmm(ctx, v656.1);

12964

                            let v720 = &C::put_in_xmm_mem(ctx, v656.0);

12965

                            let v721 = constructor_x64_pcmpgt(ctx, v708, v719, v720);

12966

                            let v722 = constructor_output_xmm(ctx, v721);

12967

                            // Rule at src/isa/x64/lower.isle line 1460.

12968

                            return Some(v722);

12969

12970

12971

                    &IntCC::SignedLessThanOrEqual => {

12972

                        let v1 = C::first_result(ctx, arg0);

12973

                        if let Some(v2) = v1 {

12974

                            let v3 = C::value_type(ctx, v2);

12975

                            if v3 == I8 {

12976

                                let v656 = C::unpack_value_array_2(ctx, v654);

12977

                                let v677 = C::def_inst(ctx, v656.0);

12978

                                if let Some(v678) = v677 {

12979

                                    let v679 = &C::inst_data(ctx, v678);

12980

                                    if let &InstructionData::UnaryImm {

12981

                                        opcode: ref v680,

12982

                                        imm: v681,

12983

                                    } = v679

12984

12985

                                        if let &Opcode::Iconst = v680 {

12986

                                            let v682 = C::u64_from_imm64(ctx, v681);

12987

                                            if v682 == 0x0 {

12988

                                                let v683 = C::value_type(ctx, v656.1);

12989

                                                match v683 {

12990

                                                    I32 => {

12991

                                                        let v684 =

12992

                                                            constructor_put_in_gpr(ctx, v656.1);

12993

                                                        let v687 =

12994

                                                            constructor_x64_not(ctx, I64, v684);

12995

                                                        let v696 = Imm8Reg::Imm8 { imm: 0x1F };

12996

                                                        let v702 =

12997

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v696);

12998

                                                        let v703 = constructor_x64_shr(

12999

                                                            ctx, I32, v687, v702,

13000

);

13001

                                                        let v704 =

13002

                                                            constructor_output_gpr(ctx, v703);

13003

                                                        // Rule at src/isa/x64/lower.isle line 1434.

13004

                                                        return Some(v704);

13005

13006

                                                    I64 => {

13007

                                                        let v684 =

13008

                                                            constructor_put_in_gpr(ctx, v656.1);

13009

                                                        let v687 =

13010

                                                            constructor_x64_not(ctx, I64, v684);

13011

                                                        let v673 = Imm8Reg::Imm8 { imm: 0x3F };

13012

                                                        let v688 =

13013

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v673);

13014

                                                        let v689 = constructor_x64_shr(

13015

                                                            ctx, I64, v687, v688,

13016

);

13017

                                                        let v690 =

13018

                                                            constructor_output_gpr(ctx, v689);

13019

                                                        // Rule at src/isa/x64/lower.isle line 1418.

13020

                                                        return Some(v690);

13021

13022

                                                    _ => {}

13023

13024

13025

13026

13027

13028

13029

13030

                        let v656 = C::unpack_value_array_2(ctx, v654);

13031

                        let v659 = C::value_type(ctx, v656.0);

13032

                        if v659 == I64X2 {

13033

                            let v709 = constructor_put_in_xmm(ctx, v656.0);

13034

                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);

13035

                            let v756 = constructor_x64_pcmpgt(ctx, I64X2, v709, v710);

13036

                            let v713 = constructor_vector_all_ones(ctx);

13037

                            let v714 = &C::xmm_to_xmm_mem(ctx, v713);

13038

                            let v757 = constructor_x64_pxor(ctx, v756, v714);

13039

                            let v758 = constructor_output_xmm(ctx, v757);

13040

                            // Rule at src/isa/x64/lower.isle line 1502.

13041

                            return Some(v758);

13042

13043

                        let v707 = C::ty_vec128(ctx, v659);

13044

                        if let Some(v708) = v707 {

13045

                            let v709 = constructor_put_in_xmm(ctx, v656.0);

13046

                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);

13047

                            let v741 = constructor_x64_pmins(ctx, v708, v709, v710);

13048

                            let v737 = constructor_put_in_xmm(ctx, v656.0);

13049

                            let v742 = &C::xmm_to_xmm_mem(ctx, v741);

13050

                            let v743 = constructor_x64_pcmpeq(ctx, v708, v737, v742);

13051

                            let v744 = constructor_output_xmm(ctx, v743);

13052

                            // Rule at src/isa/x64/lower.isle line 1486.

13053

                            return Some(v744);

13054

13055

13056

                    &IntCC::UnsignedGreaterThan => {

13057

                        let v656 = C::unpack_value_array_2(ctx, v654);

13058

                        let v659 = C::value_type(ctx, v656.0);

13059

                        let v707 = C::ty_vec128(ctx, v659);

13060

                        if let Some(v708) = v707 {

13061

                            let v709 = constructor_put_in_xmm(ctx, v656.0);

13062

                            let v723 = constructor_put_in_xmm(ctx, v656.1);

13063

                            let v724 = &C::xmm_to_xmm_mem(ctx, v723);

13064

                            let v725 = constructor_x64_pmaxu(ctx, v708, v709, v724);

13065

                            let v726 = &C::xmm_to_xmm_mem(ctx, v723);

13066

                            let v727 = constructor_x64_pcmpeq(ctx, v708, v725, v726);

13067

                            let v728 = constructor_vector_all_ones(ctx);

13068

                            let v729 = &C::xmm_to_xmm_mem(ctx, v728);

13069

                            let v730 = constructor_x64_pxor(ctx, v727, v729);

13070

                            let v731 = constructor_output_xmm(ctx, v730);

13071

                            // Rule at src/isa/x64/lower.isle line 1462.

13072

                            return Some(v731);

13073

13074

13075

                    &IntCC::UnsignedGreaterThanOrEqual => {

13076

                        let v656 = C::unpack_value_array_2(ctx, v654);

13077

                        let v659 = C::value_type(ctx, v656.0);

13078

                        let v707 = C::ty_vec128(ctx, v659);

13079

                        if let Some(v708) = v707 {

13080

                            let v709 = constructor_put_in_xmm(ctx, v656.0);

13081

                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);

13082

                            let v745 = constructor_x64_pmaxu(ctx, v708, v709, v710);

13083

                            let v737 = constructor_put_in_xmm(ctx, v656.0);

13084

                            let v746 = &C::xmm_to_xmm_mem(ctx, v745);

13085

                            let v747 = constructor_x64_pcmpeq(ctx, v708, v737, v746);

13086

                            let v748 = constructor_output_xmm(ctx, v747);

13087

                            // Rule at src/isa/x64/lower.isle line 1489.

13088

                            return Some(v748);

13089

13090

13091

                    &IntCC::UnsignedLessThan => {

13092

                        let v656 = C::unpack_value_array_2(ctx, v654);

13093

                        let v659 = C::value_type(ctx, v656.0);

13094

                        let v707 = C::ty_vec128(ctx, v659);

13095

                        if let Some(v708) = v707 {

13096

                            let v709 = constructor_put_in_xmm(ctx, v656.0);

13097

                            let v723 = constructor_put_in_xmm(ctx, v656.1);

13098

                            let v724 = &C::xmm_to_xmm_mem(ctx, v723);

13099

                            let v732 = constructor_x64_pminu(ctx, v708, v709, v724);

13100

                            let v726 = &C::xmm_to_xmm_mem(ctx, v723);

13101

                            let v733 = constructor_x64_pcmpeq(ctx, v708, v732, v726);

13102

                            let v728 = constructor_vector_all_ones(ctx);

13103

                            let v729 = &C::xmm_to_xmm_mem(ctx, v728);

13104

                            let v734 = constructor_x64_pxor(ctx, v733, v729);

13105

                            let v735 = constructor_output_xmm(ctx, v734);

13106

                            // Rule at src/isa/x64/lower.isle line 1472.

13107

                            return Some(v735);

13108

13109

13110

                    &IntCC::UnsignedLessThanOrEqual => {

13111

                        let v656 = C::unpack_value_array_2(ctx, v654);

13112

                        let v659 = C::value_type(ctx, v656.0);

13113

                        let v707 = C::ty_vec128(ctx, v659);

13114

                        if let Some(v708) = v707 {

13115

                            let v709 = constructor_put_in_xmm(ctx, v656.0);

13116

                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);

13117

                            let v749 = constructor_x64_pminu(ctx, v708, v709, v710);

13118

                            let v737 = constructor_put_in_xmm(ctx, v656.0);

13119

                            let v750 = &C::xmm_to_xmm_mem(ctx, v749);

13120

                            let v751 = constructor_x64_pcmpeq(ctx, v708, v737, v750);

13121

                            let v752 = constructor_output_xmm(ctx, v751);

13122

                            // Rule at src/isa/x64/lower.isle line 1492.

13123

                            return Some(v752);

13124

13125

13126

                    _ => {}

13127

13128

                let v656 = C::unpack_value_array_2(ctx, v654);

13129

                let v659 = C::value_type(ctx, v656.0);

13130

                if v659 == I128 {

13131

                    let v662 = &constructor_emit_cmp(ctx, v655, v656.0, v656.1);

13132

                    let v663 = constructor_lower_icmp_bool(ctx, v662);

13133

                    let v664 = C::output(ctx, v663);

13134

                    // Rule at src/isa/x64/lower.isle line 1406.

13135

                    return Some(v664);

13136

13137

                let v660 = C::fits_in_64(ctx, v659);

13138

                if let Some(v661) = v660 {

13139

                    let v662 = &constructor_emit_cmp(ctx, v655, v656.0, v656.1);

13140

                    let v663 = constructor_lower_icmp_bool(ctx, v662);

13141

                    let v664 = C::output(ctx, v663);

13142

                    // Rule at src/isa/x64/lower.isle line 1403.

13143

                    return Some(v664);

13144

13145

13146

13147

        &InstructionData::Load {

13148

            opcode: ref v1254,

13149

            arg: v1255,

13150

            flags: v1256,

13151

            offset: v1257,

13152

        } => {

13153

            match v1254 {

13154

                &Opcode::Load => {

13155

                    let v1 = C::first_result(ctx, arg0);

13156

                    if let Some(v2) = v1 {

13157

                        let v3 = C::value_type(ctx, v2);

13158

                        match v3 {

13159

                            F32 => {

13160

                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13161

                                let v1286 = &C::amode_to_synthetic_amode(ctx, v1267);

13162

                                let v1287 = constructor_x64_movss_load(ctx, v1286);

13163

                                let v1288 = constructor_output_xmm(ctx, v1287);

13164

                                // Rule at src/isa/x64/lower.isle line 2425.

13165

                                return Some(v1288);

13166

13167

                            F64 => {

13168

                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13169

                                let v1286 = &C::amode_to_synthetic_amode(ctx, v1267);

13170

                                let v1289 = constructor_x64_movsd_load(ctx, v1286);

13171

                                let v1290 = constructor_output_xmm(ctx, v1289);

13172

                                // Rule at src/isa/x64/lower.isle line 2427.

13173

                                return Some(v1290);

13174

13175

                            F32X4 => {

13176

                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13177

                                let v1286 = &C::amode_to_synthetic_amode(ctx, v1267);

13178

                                let v1291 = constructor_x64_movups_load(ctx, v1286);

13179

                                let v1292 = constructor_output_xmm(ctx, v1291);

13180

                                // Rule at src/isa/x64/lower.isle line 2429.

13181

                                return Some(v1292);

13182

13183

                            F64X2 => {

13184

                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13185

                                let v1286 = &C::amode_to_synthetic_amode(ctx, v1267);

13186

                                let v1293 = constructor_x64_movupd_load(ctx, v1286);

13187

                                let v1294 = constructor_output_xmm(ctx, v1293);

13188

                                // Rule at src/isa/x64/lower.isle line 2431.

13189

                                return Some(v1294);

13190

13191

                            _ => {}

13192

13193

                        let v1265 = C::ty_int_ref_64(ctx, v3);

13194

                        if let Some(v1266) = v1265 {

13195

                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13196

                            let v1268 = constructor_x64_mov(ctx, v1267);

13197

                            let v1269 = constructor_output_reg(ctx, v1268);

13198

                            // Rule at src/isa/x64/lower.isle line 2403.

13199

                            return Some(v1269);

13200

13201

                        let v1295 = C::ty_vec128(ctx, v3);

13202

                        if let Some(v1296) = v1295 {

13203

                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13204

                            let v1297 = &constructor_amode_to_xmm_mem(ctx, v1267);

13205

                            let v1298 = constructor_x64_movdqu_load(ctx, v1297);

13206

                            let v1299 = constructor_output_xmm(ctx, v1298);

13207

                            // Rule at src/isa/x64/lower.isle line 2433.

13208

                            return Some(v1299);

13209

13210

                        if v3 == I128 {

13211

                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13212

                            let v1301 = &C::amode_offset(ctx, v1267, 0x8);

13213

                            let v1302 = constructor_x64_mov(ctx, v1267);

13214

                            let v1303 = constructor_x64_mov(ctx, v1301);

13215

                            let v1304 = C::value_regs(ctx, v1302, v1303);

13216

                            let v1305 = C::output(ctx, v1304);

13217

                            // Rule at src/isa/x64/lower.isle line 2437.

13218

                            return Some(v1305);

13219

13220

                        let v997 = C::fits_in_32(ctx, v3);

13221

                        if let Some(v998) = v997 {

13222

                            let v1251 = &C::type_register_class(ctx, v3);

13223

                            if let Some(v1252) = v1251 {

13224

                                if let &RegisterClass::Gpr {

13225

                                    single_register: v1253,

13226

                                } = v1252

13227

13228

                                    let v1258 = C::ty_bits_u16(ctx, v998);

13229

                                    let v1260 = &C::ext_mode(ctx, v1258, 0x40);

13230

                                    let v1261 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13231

                                    let v1262 = &constructor_amode_to_gpr_mem(ctx, v1261);

13232

                                    let v1263 = constructor_x64_movzx(ctx, v1260, v1262);

13233

                                    let v1264 = constructor_output_gpr(ctx, v1263);

13234

                                    // Rule at src/isa/x64/lower.isle line 2399.

13235

                                    return Some(v1264);

13236

13237

13238

13239

13240

13241

                &Opcode::Uload8 => {

13242

                    let v1 = C::first_result(ctx, arg0);

13243

                    if let Some(v2) = v1 {

13244

                        let v3 = C::value_type(ctx, v2);

13245

                        let v1251 = &C::type_register_class(ctx, v3);

13246

                        if let Some(v1252) = v1251 {

13247

                            if let &RegisterClass::Gpr {

13248

                                single_register: v1253,

13249

                            } = v1252

13250

13251

                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13252

                                let v1271 = &constructor_amode_to_gpr_mem(ctx, v1267);

13253

                                let v1272 = constructor_x64_movzx(ctx, &ExtMode::BQ, v1271);

13254

                                let v1273 = constructor_output_gpr(ctx, v1272);

13255

                                // Rule at src/isa/x64/lower.isle line 2408.

13256

                                return Some(v1273);

13257

13258

13259

13260

13261

                &Opcode::Sload8 => {

13262

                    let v1 = C::first_result(ctx, arg0);

13263

                    if let Some(v2) = v1 {

13264

                        let v3 = C::value_type(ctx, v2);

13265

                        let v1251 = &C::type_register_class(ctx, v3);

13266

                        if let Some(v1252) = v1251 {

13267

                            if let &RegisterClass::Gpr {

13268

                                single_register: v1253,

13269

                            } = v1252

13270

13271

                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13272

                                let v1271 = &constructor_amode_to_gpr_mem(ctx, v1267);

13273

                                let v1274 = constructor_x64_movsx(ctx, &ExtMode::BQ, v1271);

13274

                                let v1275 = constructor_output_gpr(ctx, v1274);

13275

                                // Rule at src/isa/x64/lower.isle line 2410.

13276

                                return Some(v1275);

13277

13278

13279

13280

13281

                &Opcode::Uload16 => {

13282

                    let v1 = C::first_result(ctx, arg0);

13283

                    if let Some(v2) = v1 {

13284

                        let v3 = C::value_type(ctx, v2);

13285

                        let v1251 = &C::type_register_class(ctx, v3);

13286

                        if let Some(v1252) = v1251 {

13287

                            if let &RegisterClass::Gpr {

13288

                                single_register: v1253,

13289

                            } = v1252

13290

13291

                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13292

                                let v1271 = &constructor_amode_to_gpr_mem(ctx, v1267);

13293

                                let v1277 = constructor_x64_movzx(ctx, &ExtMode::WQ, v1271);

13294

                                let v1278 = constructor_output_gpr(ctx, v1277);

13295

                                // Rule at src/isa/x64/lower.isle line 2412.

13296

                                return Some(v1278);

13297

13298

13299

13300

13301

                &Opcode::Sload16 => {

13302

                    let v1 = C::first_result(ctx, arg0);

13303

                    if let Some(v2) = v1 {

13304

                        let v3 = C::value_type(ctx, v2);

13305

                        let v1251 = &C::type_register_class(ctx, v3);

13306

                        if let Some(v1252) = v1251 {

13307

                            if let &RegisterClass::Gpr {

13308

                                single_register: v1253,

13309

                            } = v1252

13310

13311

                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13312

                                let v1271 = &constructor_amode_to_gpr_mem(ctx, v1267);

13313

                                let v1279 = constructor_x64_movsx(ctx, &ExtMode::WQ, v1271);

13314

                                let v1280 = constructor_output_gpr(ctx, v1279);

13315

                                // Rule at src/isa/x64/lower.isle line 2414.

13316

                                return Some(v1280);

13317

13318

13319

13320

13321

                &Opcode::Uload32 => {

13322

                    let v1 = C::first_result(ctx, arg0);

13323

                    if let Some(v2) = v1 {

13324

                        let v3 = C::value_type(ctx, v2);

13325

                        let v1251 = &C::type_register_class(ctx, v3);

13326

                        if let Some(v1252) = v1251 {

13327

                            if let &RegisterClass::Gpr {

13328

                                single_register: v1253,

13329

                            } = v1252

13330

13331

                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13332

                                let v1271 = &constructor_amode_to_gpr_mem(ctx, v1267);

13333

                                let v1282 = constructor_x64_movzx(ctx, &ExtMode::LQ, v1271);

13334

                                let v1283 = constructor_output_gpr(ctx, v1282);

13335

                                // Rule at src/isa/x64/lower.isle line 2416.

13336

                                return Some(v1283);

13337

13338

13339

13340

13341

                &Opcode::Sload32 => {

13342

                    let v1 = C::first_result(ctx, arg0);

13343

                    if let Some(v2) = v1 {

13344

                        let v3 = C::value_type(ctx, v2);

13345

                        let v1251 = &C::type_register_class(ctx, v3);

13346

                        if let Some(v1252) = v1251 {

13347

                            if let &RegisterClass::Gpr {

13348

                                single_register: v1253,

13349

                            } = v1252

13350

13351

                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13352

                                let v1271 = &constructor_amode_to_gpr_mem(ctx, v1267);

13353

                                let v1284 = constructor_x64_movsx(ctx, &ExtMode::LQ, v1271);

13354

                                let v1285 = constructor_output_gpr(ctx, v1284);

13355

                                // Rule at src/isa/x64/lower.isle line 2418.

13356

                                return Some(v1285);

13357

13358

13359

13360

13361

                &Opcode::Uload8x8 => {

13362

                    let v1 = C::first_result(ctx, arg0);

13363

                    if let Some(v2) = v1 {

13364

                        let v3 = C::value_type(ctx, v2);

13365

                        if v3 == I16X8 {

13366

                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13367

                            let v1297 = &constructor_amode_to_xmm_mem(ctx, v1267);

13368

                            let v1308 = constructor_x64_pmovzxbw(ctx, v1297);

13369

                            let v1309 = constructor_output_xmm(ctx, v1308);

13370

                            // Rule at src/isa/x64/lower.isle line 2449.

13371

                            return Some(v1309);

13372

13373

13374

13375

                &Opcode::Sload8x8 => {

13376

                    let v1 = C::first_result(ctx, arg0);

13377

                    if let Some(v2) = v1 {

13378

                        let v3 = C::value_type(ctx, v2);

13379

                        if v3 == I16X8 {

13380

                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13381

                            let v1297 = &constructor_amode_to_xmm_mem(ctx, v1267);

13382

                            let v1306 = constructor_x64_pmovsxbw(ctx, v1297);

13383

                            let v1307 = constructor_output_xmm(ctx, v1306);

13384

                            // Rule at src/isa/x64/lower.isle line 2447.

13385

                            return Some(v1307);

13386

13387

13388

13389

                &Opcode::Uload16x4 => {

13390

                    let v1 = C::first_result(ctx, arg0);

13391

                    if let Some(v2) = v1 {

13392

                        let v3 = C::value_type(ctx, v2);

13393

                        if v3 == I32X4 {

13394

                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13395

                            let v1297 = &constructor_amode_to_xmm_mem(ctx, v1267);

13396

                            let v1312 = constructor_x64_pmovzxwd(ctx, v1297);

13397

                            let v1313 = constructor_output_xmm(ctx, v1312);

13398

                            // Rule at src/isa/x64/lower.isle line 2453.

13399

                            return Some(v1313);

13400

13401

13402

13403

                &Opcode::Sload16x4 => {

13404

                    let v1 = C::first_result(ctx, arg0);

13405

                    if let Some(v2) = v1 {

13406

                        let v3 = C::value_type(ctx, v2);

13407

                        if v3 == I32X4 {

13408

                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13409

                            let v1297 = &constructor_amode_to_xmm_mem(ctx, v1267);

13410

                            let v1310 = constructor_x64_pmovsxwd(ctx, v1297);

13411

                            let v1311 = constructor_output_xmm(ctx, v1310);

13412

                            // Rule at src/isa/x64/lower.isle line 2451.

13413

                            return Some(v1311);

13414

13415

13416

13417

                &Opcode::Uload32x2 => {

13418

                    let v1 = C::first_result(ctx, arg0);

13419

                    if let Some(v2) = v1 {

13420

                        let v3 = C::value_type(ctx, v2);

13421

                        if v3 == I64X2 {

13422

                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13423

                            let v1297 = &constructor_amode_to_xmm_mem(ctx, v1267);

13424

                            let v1316 = constructor_x64_pmovzxdq(ctx, v1297);

13425

                            let v1317 = constructor_output_xmm(ctx, v1316);

13426

                            // Rule at src/isa/x64/lower.isle line 2457.

13427

                            return Some(v1317);

13428

13429

13430

13431

                &Opcode::Sload32x2 => {

13432

                    let v1 = C::first_result(ctx, arg0);

13433

                    if let Some(v2) = v1 {

13434

                        let v3 = C::value_type(ctx, v2);

13435

                        if v3 == I64X2 {

13436

                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);

13437

                            let v1297 = &constructor_amode_to_xmm_mem(ctx, v1267);

13438

                            let v1314 = constructor_x64_pmovsxdq(ctx, v1297);

13439

                            let v1315 = constructor_output_xmm(ctx, v1314);

13440

                            // Rule at src/isa/x64/lower.isle line 2455.

13441

                            return Some(v1315);

13442

13443

13444

13445

                _ => {}

13446

13447

13448

        &InstructionData::LoadNoOffset {

13449

            opcode: ref v1457,

13450

            arg: v1458,

13451

            flags: v1459,

13452

        } => {

13453

            match v1457 {

13454

                &Opcode::Bitcast => {

13455

                    let v1 = C::first_result(ctx, arg0);

13456

                    if let Some(v2) = v1 {

13457

                        let v3 = C::value_type(ctx, v2);

13458

                        let v1251 = &C::type_register_class(ctx, v3);

13459

                        if let Some(v1252) = v1251 {

13460

                            match v1252 {

13461

                                &RegisterClass::Gpr {

13462

                                    single_register: v1253,

13463

                                } => {

13464

                                    let v1783 = C::value_type(ctx, v1458);

13465

                                    let v1794 = &C::type_register_class(ctx, v1783);

13466

                                    if let Some(v1795) = v1794 {

13467

                                        if let &RegisterClass::Gpr {

13468

                                            single_register: v1796,

13469

                                        } = v1795

13470

13471

                                            let v1797 = constructor_output_value(ctx, v1458);

13472

                                            // Rule at src/isa/x64/lower.isle line 3266.

13473

                                            return Some(v1797);

13474

13475

13476

13477

                                &RegisterClass::Xmm => {

13478

                                    let v1783 = C::value_type(ctx, v1458);

13479

                                    let v1794 = &C::type_register_class(ctx, v1783);

13480

                                    if let Some(v1795) = v1794 {

13481

                                        if let &RegisterClass::Xmm = v1795 {

13482

                                            let v1797 = constructor_output_value(ctx, v1458);

13483

                                            // Rule at src/isa/x64/lower.isle line 3270.

13484

                                            return Some(v1797);

13485

13486

13487

13488

                                _ => {}

13489

13490

13491

                        match v3 {

13492

                            I32 => {

13493

                                let v1783 = C::value_type(ctx, v1458);

13494

                                if v1783 == F32 {

13495

                                    let v1784 = constructor_put_in_xmm(ctx, v1458);

13496

                                    let v1785 = constructor_bitcast_xmm_to_gpr(ctx, F32, v1784);

13497

                                    let v1786 = constructor_output_gpr(ctx, v1785);

13498

                                    // Rule at src/isa/x64/lower.isle line 3253.

13499

                                    return Some(v1786);

13500

13501

13502

                            I64 => {

13503

                                let v1783 = C::value_type(ctx, v1458);

13504

                                if v1783 == F64 {

13505

                                    let v1784 = constructor_put_in_xmm(ctx, v1458);

13506

                                    let v1790 = constructor_bitcast_xmm_to_gpr(ctx, F64, v1784);

13507

                                    let v1791 = constructor_output_gpr(ctx, v1790);

13508

                                    // Rule at src/isa/x64/lower.isle line 3259.

13509

                                    return Some(v1791);

13510

13511

13512

                            F32 => {

13513

                                let v1783 = C::value_type(ctx, v1458);

13514

                                if v1783 == I32 {

13515

                                    let v1787 = constructor_put_in_gpr(ctx, v1458);

13516

                                    let v1788 = constructor_bitcast_gpr_to_xmm(ctx, I32, v1787);

13517

                                    let v1789 = constructor_output_xmm(ctx, v1788);

13518

                                    // Rule at src/isa/x64/lower.isle line 3256.

13519

                                    return Some(v1789);

13520

13521

13522

                            F64 => {

13523

                                let v1783 = C::value_type(ctx, v1458);

13524

                                if v1783 == I64 {

13525

                                    let v1787 = constructor_put_in_gpr(ctx, v1458);

13526

                                    let v1792 = constructor_bitcast_gpr_to_xmm(ctx, I64, v1787);

13527

                                    let v1793 = constructor_output_xmm(ctx, v1792);

13528

                                    // Rule at src/isa/x64/lower.isle line 3262.

13529

                                    return Some(v1793);

13530

13531

13532

                            _ => {}

13533

13534

13535

13536

                &Opcode::AtomicLoad => {

13537

                    let v1 = C::first_result(ctx, arg0);

13538

                    if let Some(v2) = v1 {

13539

                        let v3 = C::value_type(ctx, v2);

13540

                        if v3 == I64 {

13541

                            let v48 = C::zero_offset(ctx);

13542

                            let v1460 = &constructor_to_amode(ctx, v1459, v1458, v48);

13543

                            let v1461 = constructor_x64_mov(ctx, v1460);

13544

                            let v1462 = constructor_output_reg(ctx, v1461);

13545

                            // Rule at src/isa/x64/lower.isle line 2730.

13546

                            return Some(v1462);

13547

13548

                        let v997 = C::fits_in_32(ctx, v3);

13549

                        if let Some(v998) = v997 {

13550

                            let v1463 = C::ty_int(ctx, v3);

13551

                            if let Some(v1464) = v1463 {

13552

                                let v1258 = C::ty_bits_u16(ctx, v998);

13553

                                let v1260 = &C::ext_mode(ctx, v1258, 0x40);

13554

                                let v1465 = C::zero_offset(ctx);

13555

                                let v1466 = &constructor_to_amode(ctx, v1459, v1458, v1465);

13556

                                let v1467 = &constructor_amode_to_gpr_mem(ctx, v1466);

13557

                                let v1468 = constructor_x64_movzx(ctx, v1260, v1467);

13558

                                let v1469 = constructor_output_gpr(ctx, v1468);

13559

                                // Rule at src/isa/x64/lower.isle line 2732.

13560

                                return Some(v1469);

13561

13562

13563

13564

13565

                _ => {}

13566

13567

13568

        &InstructionData::MultiAry {

13569

            opcode: ref v647,

13570

            args: v648,

13571

        } => {

13572

            if let &Opcode::Return = v647 {

13573

                let v649 = C::value_list_slice(ctx, v648);

13574

                let v650 = C::value_slice_len(ctx, v649);

13575

                let v651 = C::range(ctx, 0x0, v650);

13576

                let v652 = constructor_lower_return(ctx, v651, v649);

13577

                // Rule at src/isa/x64/lower.isle line 1398.

13578

                return Some(v652);

13579

13580

13581

        &InstructionData::NullAry { opcode: ref v31 } => {

13582

            match v31 {

13583

                &Opcode::Debugtrap => {

13584

                    let v1011 = &constructor_x64_hlt(ctx);

13585

                    let v1012 = constructor_side_effect(ctx, v1011);

13586

                    // Rule at src/isa/x64/lower.isle line 2020.

13587

                    return Some(v1012);

13588

13589

                &Opcode::GetPinnedReg => {

13590

                    let v1958 = constructor_read_pinned_gpr(ctx);

13591

                    let v1959 = constructor_output_gpr(ctx, v1958);

13592

                    // Rule at src/isa/x64/lower.isle line 3538.

13593

                    return Some(v1959);

13594

13595

                &Opcode::GetFramePointer => {

13596

                    let v1533 = constructor_x64_rbp(ctx);

13597

                    let v1534 = constructor_output_reg(ctx, v1533);

13598

                    // Rule at src/isa/x64/lower.isle line 2779.

13599

                    return Some(v1534);

13600

13601

                &Opcode::GetStackPointer => {

13602

                    let v1535 = constructor_x64_rsp(ctx);

13603

                    let v1536 = constructor_output_reg(ctx, v1535);

13604

                    // Rule at src/isa/x64/lower.isle line 2782.

13605

                    return Some(v1536);

13606

13607

                &Opcode::GetReturnAddress => {

13608

                    let v1533 = constructor_x64_rbp(ctx);

13609

                    let v47 = C::mem_flags_trusted(ctx);

13610

                    let v1537 = Amode::ImmReg {

13611

                        simm32: 0x8,

13612

                        base: v1533,

13613

                        flags: v47,

13614

};

13615

                    let v1538 = &C::amode_to_synthetic_amode(ctx, &v1537);

13616

                    let v1539 = constructor_x64_load(ctx, I64, v1538, &ExtKind::None);

13617

                    let v1540 = constructor_output_reg(ctx, v1539);

13618

                    // Rule at src/isa/x64/lower.isle line 2785.

13619

                    return Some(v1540);

13620

13621

                &Opcode::Null => {

13622

                    let v1 = C::first_result(ctx, arg0);

13623

                    if let Some(v2) = v1 {

13624

                        let v3 = C::value_type(ctx, v2);

13625

                        let v32 = constructor_imm(ctx, v3, 0x0);

13626

                        let v33 = constructor_output_reg(ctx, v32);

13627

                        // Rule at src/isa/x64/lower.isle line 37.

13628

                        return Some(v33);

13629

13630

13631

                &Opcode::Nop => {

13632

                    let v2247 = C::invalid_reg(ctx);

13633

                    let v2248 = constructor_output_reg(ctx, v2247);

13634

                    // Rule at src/isa/x64/lower.isle line 3983.

13635

                    return Some(v2248);

13636

13637

                &Opcode::Fence => {

13638

                    let v1437 = &constructor_x64_mfence(ctx);

13639

                    let v1438 = constructor_side_effect(ctx, v1437);

13640

                    // Rule at src/isa/x64/lower.isle line 2708.

13641

                    return Some(v1438);

13642

13643

                _ => {}

13644

13645

13646

        &InstructionData::Shuffle {

13647

            opcode: ref v1967,

13648

            args: ref v1968,

13649

            imm: v1969,

13650

        } => {

13651

            if let &Opcode::Shuffle = v1967 {

13652

                let v1973 = C::pblendw_imm(ctx, v1969);

13653

                if let Some(v1974) = v1973 {

13654

                    let v1970 = C::unpack_value_array_2(ctx, v1968);

13655

                    let v1975 = constructor_put_in_xmm(ctx, v1970.0);

13656

                    let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);

13657

                    let v1977 = constructor_x64_pblendw(ctx, v1975, v1976, v1974);

13658

                    let v1978 = constructor_output_xmm(ctx, v1977);

13659

                    // Rule at src/isa/x64/lower.isle line 3558.

13660

                    return Some(v1978);

13661

13662

                let v1979 = C::palignr_imm_from_immediate(ctx, v1969);

13663

                if let Some(v1980) = v1979 {

13664

                    let v1970 = C::unpack_value_array_2(ctx, v1968);

13665

                    let v1981 = constructor_put_in_xmm(ctx, v1970.1);

13666

                    let v1982 = &C::put_in_xmm_mem(ctx, v1970.0);

13667

                    let v1983 = constructor_x64_palignr(ctx, v1981, v1982, v1980);

13668

                    let v1984 = constructor_output_xmm(ctx, v1983);

13669

                    // Rule at src/isa/x64/lower.isle line 3568.

13670

                    return Some(v1984);

13671

13672

                let v1985 = C::pshuflw_lhs_imm(ctx, v1969);

13673

                if let Some(v1986) = v1985 {

13674

                    let v1970 = C::unpack_value_array_2(ctx, v1968);

13675

                    let v1987 = &C::put_in_xmm_mem(ctx, v1970.0);

13676

                    let v1988 = constructor_x64_pshuflw(ctx, v1987, v1986);

13677

                    let v1989 = constructor_output_xmm(ctx, v1988);

13678

                    // Rule at src/isa/x64/lower.isle line 3579.

13679

                    return Some(v1989);

13680

13681

                let v1990 = C::pshuflw_rhs_imm(ctx, v1969);

13682

                if let Some(v1991) = v1990 {

13683

                    let v1970 = C::unpack_value_array_2(ctx, v1968);

13684

                    let v1992 = &C::put_in_xmm_mem(ctx, v1970.1);

13685

                    let v1993 = constructor_x64_pshuflw(ctx, v1992, v1991);

13686

                    let v1994 = constructor_output_xmm(ctx, v1993);

13687

                    // Rule at src/isa/x64/lower.isle line 3581.

13688

                    return Some(v1994);

13689

13690

                let v1995 = C::pshufhw_lhs_imm(ctx, v1969);

13691

                if let Some(v1996) = v1995 {

13692

                    let v1970 = C::unpack_value_array_2(ctx, v1968);

13693

                    let v1987 = &C::put_in_xmm_mem(ctx, v1970.0);

13694

                    let v1997 = constructor_x64_pshufhw(ctx, v1987, v1996);

13695

                    let v1998 = constructor_output_xmm(ctx, v1997);

13696

                    // Rule at src/isa/x64/lower.isle line 3583.

13697

                    return Some(v1998);

13698

13699

                let v1999 = C::pshufhw_rhs_imm(ctx, v1969);

13700

                if let Some(v2000) = v1999 {

13701

                    let v1970 = C::unpack_value_array_2(ctx, v1968);

13702

                    let v1992 = &C::put_in_xmm_mem(ctx, v1970.1);

13703

                    let v2001 = constructor_x64_pshufhw(ctx, v1992, v2000);

13704

                    let v2002 = constructor_output_xmm(ctx, v2001);

13705

                    // Rule at src/isa/x64/lower.isle line 3585.

13706

                    return Some(v2002);

13707

13708

                let v2003 = C::pshufd_lhs_imm(ctx, v1969);

13709

                if let Some(v2004) = v2003 {

13710

                    let v1970 = C::unpack_value_array_2(ctx, v1968);

13711

                    let v1987 = &C::put_in_xmm_mem(ctx, v1970.0);

13712

                    let v2005 = constructor_x64_pshufd(ctx, v1987, v2004);

13713

                    let v2006 = constructor_output_xmm(ctx, v2005);

13714

                    // Rule at src/isa/x64/lower.isle line 3602.

13715

                    return Some(v2006);

13716

13717

                let v2007 = C::pshufd_rhs_imm(ctx, v1969);

13718

                if let Some(v2008) = v2007 {

13719

                    let v1970 = C::unpack_value_array_2(ctx, v1968);

13720

                    let v1992 = &C::put_in_xmm_mem(ctx, v1970.1);

13721

                    let v2009 = constructor_x64_pshufd(ctx, v1992, v2008);

13722

                    let v2010 = constructor_output_xmm(ctx, v2009);

13723

                    // Rule at src/isa/x64/lower.isle line 3604.

13724

                    return Some(v2010);

13725

13726

                let v2011 = C::u128_from_immediate(ctx, v1969);

13727

                if let Some(v2012) = v2011 {

13728

                    match v2012 {

13729

                        0x0 => {

13730

                            let v1970 = C::unpack_value_array_2(ctx, v1968);

13731

                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);

13732

                            let v2029 = constructor_xmm_zero(ctx, I8X16);

13733

                            let v2030 = &C::xmm_to_xmm_mem(ctx, v2029);

13734

                            let v2031 = constructor_x64_pshufb(ctx, v1975, v2030);

13735

                            let v2032 = constructor_output_xmm(ctx, v2031);

13736

                            // Rule at src/isa/x64/lower.isle line 3641.

13737

                            return Some(v2032);

13738

13739

                        0x17071606150514041303120211011000 => {

13740

                            let v1970 = C::unpack_value_array_2(ctx, v1968);

13741

                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);

13742

                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);

13743

                            let v2015 = constructor_x64_punpcklbw(ctx, v1975, v1976);

13744

                            let v2016 = constructor_output_xmm(ctx, v2015);

13745

                            // Rule at src/isa/x64/lower.isle line 3615.

13746

                            return Some(v2016);

13747

13748

                        0x17160706151405041312030211100100 => {

13749

                            let v1970 = C::unpack_value_array_2(ctx, v1968);

13750

                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);

13751

                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);

13752

                            let v2019 = constructor_x64_punpcklwd(ctx, v1975, v1976);

13753

                            let v2020 = constructor_output_xmm(ctx, v2019);

13754

                            // Rule at src/isa/x64/lower.isle line 3621.

13755

                            return Some(v2020);

13756

13757

                        0x17161514070605041312111003020100 => {

13758

                            let v1970 = C::unpack_value_array_2(ctx, v1968);

13759

                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);

13760

                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);

13761

                            let v2023 = constructor_x64_punpckldq(ctx, v1975, v1976);

13762

                            let v2024 = constructor_output_xmm(ctx, v2023);

13763

                            // Rule at src/isa/x64/lower.isle line 3627.

13764

                            return Some(v2024);

13765

13766

                        0x17161514131211100706050403020100 => {

13767

                            let v1970 = C::unpack_value_array_2(ctx, v1968);

13768

                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);

13769

                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);

13770

                            let v2027 = constructor_x64_punpcklqdq(ctx, v1975, v1976);

13771

                            let v2028 = constructor_output_xmm(ctx, v2027);

13772

                            // Rule at src/isa/x64/lower.isle line 3633.

13773

                            return Some(v2028);

13774

13775

                        0x1F0F1E0E1D0D1C0C1B0B1A0A19091808 => {

13776

                            let v1970 = C::unpack_value_array_2(ctx, v1968);

13777

                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);

13778

                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);

13779

                            let v2013 = constructor_x64_punpckhbw(ctx, v1975, v1976);

13780

                            let v2014 = constructor_output_xmm(ctx, v2013);

13781

                            // Rule at src/isa/x64/lower.isle line 3613.

13782

                            return Some(v2014);

13783

13784

                        0x1F1E0F0E1D1C0D0C1B1A0B0A19180908 => {

13785

                            let v1970 = C::unpack_value_array_2(ctx, v1968);

13786

                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);

13787

                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);

13788

                            let v2017 = constructor_x64_punpckhwd(ctx, v1975, v1976);

13789

                            let v2018 = constructor_output_xmm(ctx, v2017);

13790

                            // Rule at src/isa/x64/lower.isle line 3619.

13791

                            return Some(v2018);

13792

13793

                        0x1F1E1D1C0F0E0D0C1B1A19180B0A0908 => {

13794

                            let v1970 = C::unpack_value_array_2(ctx, v1968);

13795

                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);

13796

                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);

13797

                            let v2021 = constructor_x64_punpckhdq(ctx, v1975, v1976);

13798

                            let v2022 = constructor_output_xmm(ctx, v2021);

13799

                            // Rule at src/isa/x64/lower.isle line 3625.

13800

                            return Some(v2022);

13801

13802

                        0x1F1E1D1C1B1A19180F0E0D0C0B0A0908 => {

13803

                            let v1970 = C::unpack_value_array_2(ctx, v1968);

13804

                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);

13805

                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);

13806

                            let v2025 = constructor_x64_punpckhqdq(ctx, v1975, v1976);

13807

                            let v2026 = constructor_output_xmm(ctx, v2025);

13808

                            // Rule at src/isa/x64/lower.isle line 3631.

13809

                            return Some(v2026);

13810

13811

                        _ => {}

13812

13813

13814

                let v2033 = C::shufps_imm(ctx, v1969);

13815

                if let Some(v2034) = v2033 {

13816

                    let v1970 = C::unpack_value_array_2(ctx, v1968);

13817

                    let v1975 = constructor_put_in_xmm(ctx, v1970.0);

13818

                    let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);

13819

                    let v2035 = constructor_x64_shufps(ctx, v1975, v1976, v2034);

13820

                    let v2036 = constructor_output_xmm(ctx, v2035);

13821

                    // Rule at src/isa/x64/lower.isle line 3654.

13822

                    return Some(v2036);

13823

13824

                let v2037 = C::shufps_rev_imm(ctx, v1969);

13825

                if let Some(v2038) = v2037 {

13826

                    let v1970 = C::unpack_value_array_2(ctx, v1968);

13827

                    let v1981 = constructor_put_in_xmm(ctx, v1970.1);

13828

                    let v1982 = &C::put_in_xmm_mem(ctx, v1970.0);

13829

                    let v2039 = constructor_x64_shufps(ctx, v1981, v1982, v2038);

13830

                    let v2040 = constructor_output_xmm(ctx, v2039);

13831

                    // Rule at src/isa/x64/lower.isle line 3656.

13832

                    return Some(v2040);

13833

13834

                let v2041 = &C::vec_mask_from_immediate(ctx, v1969);

13835

                if let Some(v2042) = v2041 {

13836

                    let v1970 = C::unpack_value_array_2(ctx, v1968);

13837

                    if v1970.0 == v1970.1 {

13838

                        let v1975 = constructor_put_in_xmm(ctx, v1970.0);

13839

                        let v2043 = C::shuffle_0_31_mask(ctx, v2042);

13840

                        let v2044 = &constructor_const_to_xmm_mem(ctx, v2043);

13841

                        let v2045 = constructor_x64_pshufb(ctx, v1975, v2044);

13842

                        let v2046 = constructor_output_xmm(ctx, v2045);

13843

                        // Rule at src/isa/x64/lower.isle line 3669.

13844

                        return Some(v2046);

13845

13846

                    let v1 = C::first_result(ctx, arg0);

13847

                    if let Some(v2) = v1 {

13848

                        let v3 = C::value_type(ctx, v2);

13849

                        let v363 = C::avx512vl_enabled(ctx, v3);

13850

                        if v363 == true {

13851

                            let v2047 = C::avx512vbmi_enabled(ctx, v3);

13852

                            if v2047 == true {

13853

                                let v2048 = C::perm_from_mask_with_zeros(ctx, v2042);

13854

                                if let Some(v2049) = v2048 {

13855

                                    let v1981 = constructor_put_in_xmm(ctx, v1970.1);

13856

                                    let v2052 = constructor_put_in_xmm(ctx, v1970.0);

13857

                                    let v2053 = constructor_x64_xmm_load_const(ctx, I8X16, v2049.0);

13858

                                    let v2054 = constructor_x64_vpermi2b(ctx, v1981, v2052, v2053);

13859

                                    let v2055 = &constructor_const_to_xmm_mem(ctx, v2049.1);

13860

                                    let v2056 = constructor_x64_andps(ctx, v2054, v2055);

13861

                                    let v2057 = constructor_output_xmm(ctx, v2056);

13862

                                    // Rule at src/isa/x64/lower.isle line 3675.

13863

                                    return Some(v2057);

13864

13865

                                let v1981 = constructor_put_in_xmm(ctx, v1970.1);

13866

                                let v2052 = constructor_put_in_xmm(ctx, v1970.0);

13867

                                let v2058 = C::perm_from_mask(ctx, v2042);

13868

                                let v2059 = constructor_x64_xmm_load_const(ctx, I8X16, v2058);

13869

                                let v2060 = constructor_x64_vpermi2b(ctx, v1981, v2052, v2059);

13870

                                let v2061 = constructor_output_xmm(ctx, v2060);

13871

                                // Rule at src/isa/x64/lower.isle line 3682.

13872

                                return Some(v2061);

13873

13874

13875

13876

                    let v1975 = constructor_put_in_xmm(ctx, v1970.0);

13877

                    let v2062 = C::shuffle_0_15_mask(ctx, v2042);

13878

                    let v2063 = &constructor_const_to_xmm_mem(ctx, v2062);

13879

                    let v2064 = constructor_x64_pshufb(ctx, v1975, v2063);

13880

                    let v2065 = constructor_put_in_xmm(ctx, v1970.1);

13881

                    let v2066 = C::shuffle_16_31_mask(ctx, v2042);

13882

                    let v2067 = &constructor_const_to_xmm_mem(ctx, v2066);

13883

                    let v2068 = constructor_x64_pshufb(ctx, v2065, v2067);

13884

                    let v2069 = &C::xmm_to_xmm_mem(ctx, v2068);

13885

                    let v2070 = constructor_x64_por(ctx, v2064, v2069);

13886

                    let v2071 = constructor_output_xmm(ctx, v2070);

13887

                    // Rule at src/isa/x64/lower.isle line 3689.

13888

                    return Some(v2071);

13889

13890

13891

13892

        &InstructionData::StackLoad {

13893

            opcode: ref v1876,

13894

            stack_slot: v1877,

13895

            offset: v1878,

13896

        } => {

13897

            if let &Opcode::StackAddr = v1876 {

13898

                let v1879 = constructor_stack_addr_impl(ctx, v1877, v1878);

13899

                let v1880 = constructor_output_gpr(ctx, v1879);

13900

                // Rule at src/isa/x64/lower.isle line 3369.

13901

                return Some(v1880);

13902

13903

13904

        &InstructionData::Store {

13905

            opcode: ref v1318,

13906

            args: ref v1319,

13907

            flags: v1320,

13908

            offset: v1321,

13909

        } => {

13910

            match v1318 {

13911

                &Opcode::Store => {

13912

                    let v1322 = C::unpack_value_array_2(ctx, v1319);

13913

                    let v1365 = C::def_inst(ctx, v1322.0);

13914

                    if let Some(v1366) = v1365 {

13915

                        let v1367 = C::first_result(ctx, v1366);

13916

                        if let Some(v1368) = v1367 {

13917

                            let v1370 = &C::inst_data(ctx, v1366);

13918

                            match v1370 {

13919

                                &InstructionData::Binary {

13920

                                    opcode: ref v1390,

13921

                                    args: ref v1391,

13922

                                } => {

13923

                                    match v1390 {

13924

                                        &Opcode::Iadd => {

13925

                                            let v1369 = C::value_type(ctx, v1368);

13926

                                            let v1388 = C::ty_32_or_64(ctx, v1369);

13927

                                            if let Some(v1389) = v1388 {

13928

                                                let v1392 = C::unpack_value_array_2(ctx, v1391);

13929

                                                let v1395 = &C::sinkable_load(ctx, v1392.0);

13930

                                                if let Some(v1396) = v1395 {

13931

                                                    let v1397 = C::def_inst(ctx, v1392.0);

13932

                                                    if let Some(v1398) = v1397 {

13933

                                                        let v1399 = &C::inst_data(ctx, v1398);

13934

                                                        if let &InstructionData::Load {

13935

                                                            opcode: ref v1400,

13936

                                                            arg: v1401,

13937

                                                            flags: v1402,

13938

                                                            offset: v1403,

13939

                                                        } = v1399

13940

13941

                                                            if let &Opcode::Load = v1400 {

13942

                                                                if v1320 == v1402 {

13943

                                                                    if v1321 == v1403 {

13944

                                                                        if v1322.1 == v1401 {

13945

                                                                            let v1404 = &constructor_sink_load_to_reg_mem_imm(ctx, v1396);

13946

                                                                            let v1405 = &constructor_to_amode(ctx, v1402, v1401, v1403);

13947

                                                                            let v1406 = constructor_put_in_gpr(ctx, v1392.1);

13948

                                                                            let v1407 = &constructor_x64_add_mem(ctx, v1389, v1405, v1406);

13949

                                                                            let v1408 = constructor_side_effect(ctx, v1407);

13950

                                                                            // Rule at src/isa/x64/lower.isle line 2581.

13951

                                                                            return Some(v1408);

13952

13953

13954

13955

13956

13957

13958

13959

                                                let v1409 = &C::sinkable_load(ctx, v1392.1);

13960

                                                if let Some(v1410) = v1409 {

13961

                                                    let v1411 = C::def_inst(ctx, v1392.1);

13962

                                                    if let Some(v1412) = v1411 {

13963

                                                        let v1413 = &C::inst_data(ctx, v1412);

13964

                                                        if let &InstructionData::Load {

13965

                                                            opcode: ref v1414,

13966

                                                            arg: v1415,

13967

                                                            flags: v1416,

13968

                                                            offset: v1417,

13969

                                                        } = v1413

13970

13971

                                                            if let &Opcode::Load = v1414 {

13972

                                                                if v1320 == v1416 {

13973

                                                                    if v1321 == v1417 {

13974

                                                                        if v1322.1 == v1415 {

13975

                                                                            let v1418 = &constructor_sink_load_to_reg_mem_imm(ctx, v1410);

13976

                                                                            let v1419 = &constructor_to_amode(ctx, v1416, v1415, v1417);

13977

                                                                            let v1420 = constructor_put_in_gpr(ctx, v1392.0);

13978

                                                                            let v1421 = &constructor_x64_add_mem(ctx, v1389, v1419, v1420);

13979

                                                                            let v1422 = constructor_side_effect(ctx, v1421);

13980

                                                                            // Rule at src/isa/x64/lower.isle line 2595.

13981

                                                                            return Some(v1422);

13982

13983

13984

13985

13986

13987

13988

13989

13990

13991

                                        &Opcode::Isub => {

13992

                                            let v1369 = C::value_type(ctx, v1368);

13993

                                            let v1388 = C::ty_32_or_64(ctx, v1369);

13994

                                            if let Some(v1389) = v1388 {

13995

                                                let v1392 = C::unpack_value_array_2(ctx, v1391);

13996

                                                let v1395 = &C::sinkable_load(ctx, v1392.0);

13997

                                                if let Some(v1396) = v1395 {

13998

                                                    let v1397 = C::def_inst(ctx, v1392.0);

13999

                                                    if let Some(v1398) = v1397 {

14000

                                                        let v1399 = &C::inst_data(ctx, v1398);

14001

                                                        if let &InstructionData::Load {

14002

                                                            opcode: ref v1400,

14003

                                                            arg: v1401,

14004

                                                            flags: v1402,

14005

                                                            offset: v1403,

14006

                                                        } = v1399

14007

14008

                                                            if let &Opcode::Load = v1400 {

14009

                                                                if v1320 == v1402 {

14010

                                                                    if v1321 == v1403 {

14011

                                                                        if v1322.1 == v1401 {

14012

                                                                            let v1404 = &constructor_sink_load_to_reg_mem_imm(ctx, v1396);

14013

                                                                            let v1405 = &constructor_to_amode(ctx, v1402, v1401, v1403);

14014

                                                                            let v1406 = constructor_put_in_gpr(ctx, v1392.1);

14015

                                                                            let v1423 = &constructor_x64_sub_mem(ctx, v1389, v1405, v1406);

14016

                                                                            let v1424 = constructor_side_effect(ctx, v1423);

14017

                                                                            // Rule at src/isa/x64/lower.isle line 2609.

14018

                                                                            return Some(v1424);

14019

14020

14021

14022

14023

14024

14025

14026

14027

14028

                                        &Opcode::Band => {

14029

                                            let v1369 = C::value_type(ctx, v1368);

14030

                                            let v1388 = C::ty_32_or_64(ctx, v1369);

14031

                                            if let Some(v1389) = v1388 {

14032

                                                let v1392 = C::unpack_value_array_2(ctx, v1391);

14033

                                                let v1395 = &C::sinkable_load(ctx, v1392.0);

14034

                                                if let Some(v1396) = v1395 {

14035

                                                    let v1397 = C::def_inst(ctx, v1392.0);

14036

                                                    if let Some(v1398) = v1397 {

14037

                                                        let v1399 = &C::inst_data(ctx, v1398);

14038

                                                        if let &InstructionData::Load {

14039

                                                            opcode: ref v1400,

14040

                                                            arg: v1401,

14041

                                                            flags: v1402,

14042

                                                            offset: v1403,

14043

                                                        } = v1399

14044

14045

                                                            if let &Opcode::Load = v1400 {

14046

                                                                if v1320 == v1402 {

14047

                                                                    if v1321 == v1403 {

14048

                                                                        if v1322.1 == v1401 {

14049

                                                                            let v1404 = &constructor_sink_load_to_reg_mem_imm(ctx, v1396);

14050

                                                                            let v1405 = &constructor_to_amode(ctx, v1402, v1401, v1403);

14051

                                                                            let v1406 = constructor_put_in_gpr(ctx, v1392.1);

14052

                                                                            let v1425 = &constructor_x64_and_mem(ctx, v1389, v1405, v1406);

14053

                                                                            let v1426 = constructor_side_effect(ctx, v1425);

14054

                                                                            // Rule at src/isa/x64/lower.isle line 2623.

14055

                                                                            return Some(v1426);

14056

14057

14058

14059

14060

14061

14062

14063

                                                let v1409 = &C::sinkable_load(ctx, v1392.1);

14064

                                                if let Some(v1410) = v1409 {

14065

                                                    let v1411 = C::def_inst(ctx, v1392.1);

14066

                                                    if let Some(v1412) = v1411 {

14067

                                                        let v1413 = &C::inst_data(ctx, v1412);

14068

                                                        if let &InstructionData::Load {

14069

                                                            opcode: ref v1414,

14070

                                                            arg: v1415,

14071

                                                            flags: v1416,

14072

                                                            offset: v1417,

14073

                                                        } = v1413

14074

14075

                                                            if let &Opcode::Load = v1414 {

14076

                                                                if v1320 == v1416 {

14077

                                                                    if v1321 == v1417 {

14078

                                                                        if v1322.1 == v1415 {

14079

                                                                            let v1418 = &constructor_sink_load_to_reg_mem_imm(ctx, v1410);

14080

                                                                            let v1419 = &constructor_to_amode(ctx, v1416, v1415, v1417);

14081

                                                                            let v1420 = constructor_put_in_gpr(ctx, v1392.0);

14082

                                                                            let v1427 = &constructor_x64_and_mem(ctx, v1389, v1419, v1420);

14083

                                                                            let v1428 = constructor_side_effect(ctx, v1427);

14084

                                                                            // Rule at src/isa/x64/lower.isle line 2637.

14085

                                                                            return Some(v1428);

14086

14087

14088

14089

14090

14091

14092

14093

14094

14095

                                        &Opcode::Bor => {

14096

                                            let v1369 = C::value_type(ctx, v1368);

14097

                                            let v1388 = C::ty_32_or_64(ctx, v1369);

14098

                                            if let Some(v1389) = v1388 {

14099

                                                let v1392 = C::unpack_value_array_2(ctx, v1391);

14100

                                                let v1395 = &C::sinkable_load(ctx, v1392.0);

14101

                                                if let Some(v1396) = v1395 {

14102

                                                    let v1397 = C::def_inst(ctx, v1392.0);

14103

                                                    if let Some(v1398) = v1397 {

14104

                                                        let v1399 = &C::inst_data(ctx, v1398);

14105

                                                        if let &InstructionData::Load {

14106

                                                            opcode: ref v1400,

14107

                                                            arg: v1401,

14108

                                                            flags: v1402,

14109

                                                            offset: v1403,

14110

                                                        } = v1399

14111

14112

                                                            if let &Opcode::Load = v1400 {

14113

                                                                if v1320 == v1402 {

14114

                                                                    if v1321 == v1403 {

14115

                                                                        if v1322.1 == v1401 {

14116

                                                                            let v1404 = &constructor_sink_load_to_reg_mem_imm(ctx, v1396);

14117

                                                                            let v1405 = &constructor_to_amode(ctx, v1402, v1401, v1403);

14118

                                                                            let v1406 = constructor_put_in_gpr(ctx, v1392.1);

14119

                                                                            let v1429 = &constructor_x64_or_mem(ctx, v1389, v1405, v1406);

14120

                                                                            let v1430 = constructor_side_effect(ctx, v1429);

14121

                                                                            // Rule at src/isa/x64/lower.isle line 2651.

14122

                                                                            return Some(v1430);

14123

14124

14125

14126

14127

14128

14129

14130

                                                let v1409 = &C::sinkable_load(ctx, v1392.1);

14131

                                                if let Some(v1410) = v1409 {

14132

                                                    let v1411 = C::def_inst(ctx, v1392.1);

14133

                                                    if let Some(v1412) = v1411 {

14134

                                                        let v1413 = &C::inst_data(ctx, v1412);

14135

                                                        if let &InstructionData::Load {

14136

                                                            opcode: ref v1414,

14137

                                                            arg: v1415,

14138

                                                            flags: v1416,

14139

                                                            offset: v1417,

14140

                                                        } = v1413

14141

14142

                                                            if let &Opcode::Load = v1414 {

14143

                                                                if v1320 == v1416 {

14144

                                                                    if v1321 == v1417 {

14145

                                                                        if v1322.1 == v1415 {

14146

                                                                            let v1418 = &constructor_sink_load_to_reg_mem_imm(ctx, v1410);

14147

                                                                            let v1419 = &constructor_to_amode(ctx, v1416, v1415, v1417);

14148

                                                                            let v1420 = constructor_put_in_gpr(ctx, v1392.0);

14149

                                                                            let v1431 = &constructor_x64_or_mem(ctx, v1389, v1419, v1420);

14150

                                                                            let v1432 = constructor_side_effect(ctx, v1431);

14151

                                                                            // Rule at src/isa/x64/lower.isle line 2665.

14152

                                                                            return Some(v1432);

14153

14154

14155

14156

14157

14158

14159

14160

14161

14162

                                        &Opcode::Bxor => {

14163

                                            let v1369 = C::value_type(ctx, v1368);

14164

                                            let v1388 = C::ty_32_or_64(ctx, v1369);

14165

                                            if let Some(v1389) = v1388 {

14166

                                                let v1392 = C::unpack_value_array_2(ctx, v1391);

14167

                                                let v1395 = &C::sinkable_load(ctx, v1392.0);

14168

                                                if let Some(v1396) = v1395 {

14169

                                                    let v1397 = C::def_inst(ctx, v1392.0);

14170

                                                    if let Some(v1398) = v1397 {

14171

                                                        let v1399 = &C::inst_data(ctx, v1398);

14172

                                                        if let &InstructionData::Load {

14173

                                                            opcode: ref v1400,

14174

                                                            arg: v1401,

14175

                                                            flags: v1402,

14176

                                                            offset: v1403,

14177

                                                        } = v1399

14178

14179

                                                            if let &Opcode::Load = v1400 {

14180

                                                                if v1320 == v1402 {

14181

                                                                    if v1321 == v1403 {

14182

                                                                        if v1322.1 == v1401 {

14183

                                                                            let v1404 = &constructor_sink_load_to_reg_mem_imm(ctx, v1396);

14184

                                                                            let v1405 = &constructor_to_amode(ctx, v1402, v1401, v1403);

14185

                                                                            let v1406 = constructor_put_in_gpr(ctx, v1392.1);

14186

                                                                            let v1433 = &constructor_x64_xor_mem(ctx, v1389, v1405, v1406);

14187

                                                                            let v1434 = constructor_side_effect(ctx, v1433);

14188

                                                                            // Rule at src/isa/x64/lower.isle line 2679.

14189

                                                                            return Some(v1434);

14190

14191

14192

14193

14194

14195

14196

14197

                                                let v1409 = &C::sinkable_load(ctx, v1392.1);

14198

                                                if let Some(v1410) = v1409 {

14199

                                                    let v1411 = C::def_inst(ctx, v1392.1);

14200

                                                    if let Some(v1412) = v1411 {

14201

                                                        let v1413 = &C::inst_data(ctx, v1412);

14202

                                                        if let &InstructionData::Load {

14203

                                                            opcode: ref v1414,

14204

                                                            arg: v1415,

14205

                                                            flags: v1416,

14206

                                                            offset: v1417,

14207

                                                        } = v1413

14208

14209

                                                            if let &Opcode::Load = v1414 {

14210

                                                                if v1320 == v1416 {

14211

                                                                    if v1321 == v1417 {

14212

                                                                        if v1322.1 == v1415 {

14213

                                                                            let v1418 = &constructor_sink_load_to_reg_mem_imm(ctx, v1410);

14214

                                                                            let v1419 = &constructor_to_amode(ctx, v1416, v1415, v1417);

14215

                                                                            let v1420 = constructor_put_in_gpr(ctx, v1392.0);

14216

                                                                            let v1435 = &constructor_x64_xor_mem(ctx, v1389, v1419, v1420);

14217

                                                                            let v1436 = constructor_side_effect(ctx, v1435);

14218

                                                                            // Rule at src/isa/x64/lower.isle line 2693.

14219

                                                                            return Some(v1436);

14220

14221

14222

14223

14224

14225

14226

14227

14228

14229

                                        _ => {}

14230

14231

14232

                                &InstructionData::BinaryImm8 {

14233

                                    opcode: ref v1371,

14234

                                    arg: v1372,

14235

                                    imm: v1373,

14236

                                } => {

14237

                                    if let &Opcode::Extractlane = v1371 {

14238

                                        let v1369 = C::value_type(ctx, v1368);

14239

                                        match v1369 {

14240

                                            I8 => {

14241

                                                let v1329 = &constructor_to_amode(

14242

                                                    ctx, v1320, v1322.1, v1321,

14243

);

14244

                                                let v1330 =

14245

                                                    &C::amode_to_synthetic_amode(ctx, v1329);

14246

                                                let v1375 = constructor_put_in_xmm(ctx, v1372);

14247

                                                let v1374 = C::u8_from_uimm8(ctx, v1373);

14248

                                                let v1380 = &constructor_x64_pextrb_store(

14249

                                                    ctx, v1330, v1375, v1374,

14250

);

14251

                                                let v1381 = constructor_side_effect(ctx, v1380);

14252

                                                // Rule at src/isa/x64/lower.isle line 2553.

14253

                                                return Some(v1381);

14254

14255

                                            I16 => {

14256

                                                let v1329 = &constructor_to_amode(

14257

                                                    ctx, v1320, v1322.1, v1321,

14258

);

14259

                                                let v1330 =

14260

                                                    &C::amode_to_synthetic_amode(ctx, v1329);

14261

                                                let v1375 = constructor_put_in_xmm(ctx, v1372);

14262

                                                let v1374 = C::u8_from_uimm8(ctx, v1373);

14263

                                                let v1382 = &constructor_x64_pextrw_store(

14264

                                                    ctx, v1330, v1375, v1374,

14265

);

14266

                                                let v1383 = constructor_side_effect(ctx, v1382);

14267

                                                // Rule at src/isa/x64/lower.isle line 2559.

14268

                                                return Some(v1383);

14269

14270

                                            I32 => {

14271

                                                let v1329 = &constructor_to_amode(

14272

                                                    ctx, v1320, v1322.1, v1321,

14273

);

14274

                                                let v1330 =

14275

                                                    &C::amode_to_synthetic_amode(ctx, v1329);

14276

                                                let v1375 = constructor_put_in_xmm(ctx, v1372);

14277

                                                let v1374 = C::u8_from_uimm8(ctx, v1373);

14278

                                                let v1384 = &constructor_x64_pextrd_store(

14279

                                                    ctx, v1330, v1375, v1374,

14280

);

14281

                                                let v1385 = constructor_side_effect(ctx, v1384);

14282

                                                // Rule at src/isa/x64/lower.isle line 2565.

14283

                                                return Some(v1385);

14284

14285

                                            I64 => {

14286

                                                let v1329 = &constructor_to_amode(

14287

                                                    ctx, v1320, v1322.1, v1321,

14288

);

14289

                                                let v1330 =

14290

                                                    &C::amode_to_synthetic_amode(ctx, v1329);

14291

                                                let v1375 = constructor_put_in_xmm(ctx, v1372);

14292

                                                let v1374 = C::u8_from_uimm8(ctx, v1373);

14293

                                                let v1386 = &constructor_x64_pextrq_store(

14294

                                                    ctx, v1330, v1375, v1374,

14295

);

14296

                                                let v1387 = constructor_side_effect(ctx, v1386);

14297

                                                // Rule at src/isa/x64/lower.isle line 2571.

14298

                                                return Some(v1387);

14299

14300

                                            F32 => {

14301

                                                let v1374 = C::u8_from_uimm8(ctx, v1373);

14302

                                                if v1374 == 0x0 {

14303

                                                    let v1329 = &constructor_to_amode(

14304

                                                        ctx, v1320, v1322.1, v1321,

14305

);

14306

                                                    let v1330 =

14307

                                                        &C::amode_to_synthetic_amode(ctx, v1329);

14308

                                                    let v1375 = constructor_put_in_xmm(ctx, v1372);

14309

                                                    let v1376 = &constructor_x64_movss_store(

14310

                                                        ctx, v1330, v1375,

14311

);

14312

                                                    let v1377 = constructor_side_effect(ctx, v1376);

14313

                                                    // Rule at src/isa/x64/lower.isle line 2541.

14314

                                                    return Some(v1377);

14315

14316

14317

                                            F64 => {

14318

                                                let v1374 = C::u8_from_uimm8(ctx, v1373);

14319

                                                if v1374 == 0x0 {

14320

                                                    let v1329 = &constructor_to_amode(

14321

                                                        ctx, v1320, v1322.1, v1321,

14322

);

14323

                                                    let v1330 =

14324

                                                        &C::amode_to_synthetic_amode(ctx, v1329);

14325

                                                    let v1375 = constructor_put_in_xmm(ctx, v1372);

14326

                                                    let v1378 = &constructor_x64_movsd_store(

14327

                                                        ctx, v1330, v1375,

14328

);

14329

                                                    let v1379 = constructor_side_effect(ctx, v1378);

14330

                                                    // Rule at src/isa/x64/lower.isle line 2547.

14331

                                                    return Some(v1379);

14332

14333

14334

                                            _ => {}

14335

14336

14337

14338

                                _ => {}

14339

14340

14341

14342

                    let v1325 = C::value_type(ctx, v1322.0);

14343

                    match v1325 {

14344

                        I128 => {

14345

                            let v1354 = C::put_in_regs(ctx, v1322.0);

14346

                            let v1355 = constructor_value_regs_get_gpr(ctx, v1354, 0x0);

14347

                            let v1356 = constructor_value_regs_get_gpr(ctx, v1354, 0x1);

14348

                            let v1357 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);

14349

                            let v1358 = &C::amode_offset(ctx, v1357, 0x8);

14350

                            let v1359 = &C::amode_to_synthetic_amode(ctx, v1357);

14351

                            let v1360 = &constructor_x64_movrm(ctx, I64, v1359, v1355);

14352

                            let v1361 = &C::amode_to_synthetic_amode(ctx, v1358);

14353

                            let v1362 = &constructor_x64_movrm(ctx, I64, v1361, v1356);

14354

                            let v1363 = &constructor_side_effect_concat(ctx, v1360, v1362);

14355

                            let v1364 = constructor_side_effect(ctx, v1363);

14356

                            // Rule at src/isa/x64/lower.isle line 2522.

14357

                            return Some(v1364);

14358

14359

                        F32 => {

14360

                            let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);

14361

                            let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);

14362

                            let v1341 = constructor_put_in_xmm(ctx, v1322.0);

14363

                            let v1342 = &constructor_x64_movss_store(ctx, v1330, v1341);

14364

                            let v1343 = constructor_side_effect(ctx, v1342);

14365

                            // Rule at src/isa/x64/lower.isle line 2482.

14366

                            return Some(v1343);

14367

14368

                        F64 => {

14369

                            let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);

14370

                            let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);

14371

                            let v1341 = constructor_put_in_xmm(ctx, v1322.0);

14372

                            let v1344 = &constructor_x64_movsd_store(ctx, v1330, v1341);

14373

                            let v1345 = constructor_side_effect(ctx, v1344);

14374

                            // Rule at src/isa/x64/lower.isle line 2490.

14375

                            return Some(v1345);

14376

14377

                        F32X4 => {

14378

                            let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);

14379

                            let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);

14380

                            let v1341 = constructor_put_in_xmm(ctx, v1322.0);

14381

                            let v1346 = &constructor_x64_movups_store(ctx, v1330, v1341);

14382

                            let v1347 = constructor_side_effect(ctx, v1346);

14383

                            // Rule at src/isa/x64/lower.isle line 2498.

14384

                            return Some(v1347);

14385

14386

                        F64X2 => {

14387

                            let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);

14388

                            let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);

14389

                            let v1341 = constructor_put_in_xmm(ctx, v1322.0);

14390

                            let v1348 = &constructor_x64_movupd_store(ctx, v1330, v1341);

14391

                            let v1349 = constructor_side_effect(ctx, v1348);

14392

                            // Rule at src/isa/x64/lower.isle line 2506.

14393

                            return Some(v1349);

14394

14395

                        _ => {}

14396

14397

                    let v1350 = C::ty_vec128_int(ctx, v1325);

14398

                    if let Some(v1351) = v1350 {

14399

                        let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);

14400

                        let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);

14401

                        let v1341 = constructor_put_in_xmm(ctx, v1322.0);

14402

                        let v1352 = &constructor_x64_movdqu_store(ctx, v1330, v1341);

14403

                        let v1353 = constructor_side_effect(ctx, v1352);

14404

                        // Rule at src/isa/x64/lower.isle line 2514.

14405

                        return Some(v1353);

14406

14407

                    let v1326 = &C::type_register_class(ctx, v1325);

14408

                    if let Some(v1327) = v1326 {

14409

                        if let &RegisterClass::Gpr {

14410

                            single_register: v1328,

14411

                        } = v1327

14412

14413

                            let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);

14414

                            let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);

14415

                            let v1331 = constructor_put_in_gpr(ctx, v1322.0);

14416

                            let v1332 = &constructor_x64_movrm(ctx, v1325, v1330, v1331);

14417

                            let v1333 = constructor_side_effect(ctx, v1332);

14418

                            // Rule at src/isa/x64/lower.isle line 2463.

14419

                            return Some(v1333);

14420

14421

14422

14423

                &Opcode::Istore8 => {

14424

                    let v1322 = C::unpack_value_array_2(ctx, v1319);

14425

                    let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);

14426

                    let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);

14427

                    let v1331 = constructor_put_in_gpr(ctx, v1322.0);

14428

                    let v1335 = &constructor_x64_movrm(ctx, I8, v1330, v1331);

14429

                    let v1336 = constructor_side_effect(ctx, v1335);

14430

                    // Rule at src/isa/x64/lower.isle line 2471.

14431

                    return Some(v1336);

14432

14433

                &Opcode::Istore16 => {

14434

                    let v1322 = C::unpack_value_array_2(ctx, v1319);

14435

                    let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);

14436

                    let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);

14437

                    let v1331 = constructor_put_in_gpr(ctx, v1322.0);

14438

                    let v1337 = &constructor_x64_movrm(ctx, I16, v1330, v1331);

14439

                    let v1338 = constructor_side_effect(ctx, v1337);

14440

                    // Rule at src/isa/x64/lower.isle line 2474.

14441

                    return Some(v1338);

14442

14443

                &Opcode::Istore32 => {

14444

                    let v1322 = C::unpack_value_array_2(ctx, v1319);

14445

                    let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);

14446

                    let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);

14447

                    let v1331 = constructor_put_in_gpr(ctx, v1322.0);

14448

                    let v1339 = &constructor_x64_movrm(ctx, I32, v1330, v1331);

14449

                    let v1340 = constructor_side_effect(ctx, v1339);

14450

                    // Rule at src/isa/x64/lower.isle line 2477.

14451

                    return Some(v1340);

14452

14453

                _ => {}

14454

14455

14456

        &InstructionData::StoreNoOffset {

14457

            opcode: ref v1470,

14458

            args: ref v1471,

14459

            flags: v1472,

14460

        } => {

14461

            if let &Opcode::AtomicStore = v1470 {

14462

                let v1473 = C::unpack_value_array_2(ctx, v1471);

14463

                let v1476 = C::value_type(ctx, v1473.0);

14464

                let v1477 = C::fits_in_64(ctx, v1476);

14465

                if let Some(v1478) = v1477 {

14466

                    let v1479 = C::ty_int(ctx, v1476);

14467

                    if let Some(v1480) = v1479 {

14468

                        let v48 = C::zero_offset(ctx);

14469

                        let v1481 = &constructor_to_amode(ctx, v1472, v1473.1, v48);

14470

                        let v1482 = &C::amode_to_synthetic_amode(ctx, v1481);

14471

                        let v1483 = constructor_put_in_gpr(ctx, v1473.0);

14472

                        let v1484 = &constructor_x64_movrm(ctx, v1478, v1482, v1483);

14473

                        let v1485 = &constructor_x64_mfence(ctx);

14474

                        let v1486 = &constructor_side_effect_concat(ctx, v1484, v1485);

14475

                        let v1487 = constructor_side_effect(ctx, v1486);

14476

                        // Rule at src/isa/x64/lower.isle line 2740.

14477

                        return Some(v1487);

14478

14479

14480

14481

14482

        &InstructionData::Ternary {

14483

            opcode: ref v541,

14484

            args: ref v542,

14485

        } => {

14486

            match v541 {

14487

                &Opcode::Select => {

14488

                    let v1 = C::first_result(ctx, arg0);

14489

                    if let Some(v2) = v1 {

14490

                        let v543 = C::unpack_value_array_3(ctx, v542);

14491

                        let v809 = C::maybe_uextend(ctx, v543.0);

14492

                        if let Some(v810) = v809 {

14493

                            let v811 = C::def_inst(ctx, v810);

14494

                            if let Some(v812) = v811 {

14495

                                let v813 = &C::inst_data(ctx, v812);

14496

                                match v813 {

14497

                                    &InstructionData::FloatCompare {

14498

                                        opcode: ref v814,

14499

                                        args: ref v815,

14500

                                        cond: ref v816,

14501

                                    } => {

14502

                                        if let &Opcode::Fcmp = v814 {

14503

                                            if let &FloatCC::Equal = v816 {

14504

                                                let v817 = C::unpack_value_array_2(ctx, v815);

14505

                                                let v823 = &constructor_emit_fcmp(

14506

                                                    ctx,

14507

                                                    &FloatCC::NotEqual,

14508

                                                    v817.0,

14509

                                                    v817.1,

14510

);

14511

                                                let v3 = C::value_type(ctx, v2);

14512

                                                let v824 = constructor_lower_select_fcmp(

14513

                                                    ctx, v3, v823, v543.2, v543.1,

14514

);

14515

                                                // Rule at src/isa/x64/lower.isle line 1584.

14516

                                                return Some(v824);

14517

14518

                                            let v817 = C::unpack_value_array_2(ctx, v815);

14519

                                            let v820 =

14520

                                                &constructor_emit_fcmp(ctx, v816, v817.0, v817.1);

14521

                                            let v3 = C::value_type(ctx, v2);

14522

                                            let v821 = constructor_lower_select_fcmp(

14523

                                                ctx, v3, v820, v543.1, v543.2,

14524

);

14525

                                            // Rule at src/isa/x64/lower.isle line 1582.

14526

                                            return Some(v821);

14527

14528

14529

                                    &InstructionData::IntCompare {

14530

                                        opcode: ref v825,

14531

                                        args: ref v826,

14532

                                        cond: ref v827,

14533

                                    } => {

14534

                                        if let &Opcode::Icmp = v825 {

14535

                                            let v828 = C::unpack_value_array_2(ctx, v826);

14536

                                            let v831 = C::value_type(ctx, v828.0);

14537

                                            let v832 = C::fits_in_64(ctx, v831);

14538

                                            if let Some(v833) = v832 {

14539

                                                let v834 = &C::raw_operand_size_of_type(ctx, v833);

14540

                                                let v835 =

14541

                                                    &constructor_put_in_gpr_mem_imm(ctx, v828.1);

14542

                                                let v836 = constructor_put_in_gpr(ctx, v828.0);

14543

                                                let v837 =

14544

                                                    &constructor_x64_cmp(ctx, v834, v835, v836);

14545

                                                let v838 = &C::intcc_to_cc(ctx, v827);

14546

                                                let v3 = C::value_type(ctx, v2);

14547

                                                let v839 = &constructor_cmove_from_values(

14548

                                                    ctx, v3, v838, v543.1, v543.2,

14549

);

14550

                                                let v840 = constructor_with_flags(ctx, v837, v839);

14551

                                                let v841 = C::output(ctx, v840);

14552

                                                // Rule at src/isa/x64/lower.isle line 1598.

14553

                                                return Some(v841);

14554

14555

14556

14557

                                    _ => {}

14558

14559

14560

14561

                        let v842 = C::value_type(ctx, v543.0);

14562

                        let v843 = C::fits_in_64(ctx, v842);

14563

                        if let Some(v844) = v843 {

14564

                            let v845 = &C::raw_operand_size_of_type(ctx, v844);

14565

                            let v846 = constructor_put_in_gpr(ctx, v543.0);

14566

                            let v847 = &C::gpr_to_gpr_mem_imm(ctx, v846);

14567

                            let v848 = &constructor_x64_test(ctx, v845, v847, v846);

14568

                            let v3 = C::value_type(ctx, v2);

14569

                            let v850 =

14570

                                &constructor_cmove_from_values(ctx, v3, &CC::NZ, v543.1, v543.2);

14571

                            let v851 = constructor_with_flags(ctx, v848, v850);

14572

                            let v852 = C::output(ctx, v851);

14573

                            // Rule at src/isa/x64/lower.isle line 1605.

14574

                            return Some(v852);

14575

14576

                        if v842 == I128 {

14577

                            let v854 = C::put_in_regs(ctx, v543.0);

14578

                            let v855 = &constructor_cmp_zero_i128(ctx, &CC::Z, v854);

14579

                            let v856 = constructor_select_icmp(ctx, v855, v543.1, v543.2);

14580

                            let v857 = C::output(ctx, v856);

14581

                            // Rule at src/isa/x64/lower.isle line 1612.

14582

                            return Some(v857);

14583

14584

14585

14586

                &Opcode::SelectSpectreGuard => {

14587

                    let v543 = C::unpack_value_array_3(ctx, v542);

14588

                    let v1541 = C::def_inst(ctx, v543.0);

14589

                    if let Some(v1542) = v1541 {

14590

                        let v1543 = &C::inst_data(ctx, v1542);

14591

                        if let &InstructionData::IntCompare {

14592

                            opcode: ref v1544,

14593

                            args: ref v1545,

14594

                            cond: ref v1546,

14595

                        } = v1543

14596

14597

                            if let &Opcode::Icmp = v1544 {

14598

                                let v1547 = C::unpack_value_array_2(ctx, v1545);

14599

                                let v1550 = &constructor_emit_cmp(ctx, v1546, v1547.0, v1547.1);

14600

                                let v1551 = constructor_select_icmp(ctx, v1550, v543.1, v543.2);

14601

                                let v1552 = C::output(ctx, v1551);

14602

                                // Rule at src/isa/x64/lower.isle line 2851.

14603

                                return Some(v1552);

14604

14605

14606

14607

                    let v1 = C::first_result(ctx, arg0);

14608

                    if let Some(v2) = v1 {

14609

                        let v842 = C::value_type(ctx, v543.0);

14610

                        let v843 = C::fits_in_64(ctx, v842);

14611

                        if let Some(v844) = v843 {

14612

                            let v845 = &C::raw_operand_size_of_type(ctx, v844);

14613

                            let v846 = constructor_put_in_gpr(ctx, v543.0);

14614

                            let v847 = &C::gpr_to_gpr_mem_imm(ctx, v846);

14615

                            let v848 = &constructor_x64_test(ctx, v845, v847, v846);

14616

                            let v3 = C::value_type(ctx, v2);

14617

                            let v850 =

14618

                                &constructor_cmove_from_values(ctx, v3, &CC::NZ, v543.1, v543.2);

14619

                            let v851 = constructor_with_flags(ctx, v848, v850);

14620

                            let v852 = C::output(ctx, v851);

14621

                            // Rule at src/isa/x64/lower.isle line 2854.

14622

                            return Some(v852);

14623

14624

                        if v842 == I128 {

14625

                            let v854 = C::put_in_regs(ctx, v543.0);

14626

                            let v855 = &constructor_cmp_zero_i128(ctx, &CC::Z, v854);

14627

                            let v856 = constructor_select_icmp(ctx, v855, v543.1, v543.2);

14628

                            let v857 = C::output(ctx, v856);

14629

                            // Rule at src/isa/x64/lower.isle line 2859.

14630

                            return Some(v857);

14631

14632

14633

14634

                &Opcode::Bitselect => {

14635

                    let v1 = C::first_result(ctx, arg0);

14636

                    if let Some(v2) = v1 {

14637

                        let v3 = C::value_type(ctx, v2);

14638

                        let v64 = C::multi_lane(ctx, v3);

14639

                        if let Some(v65) = v64 {

14640

                            let v543 = C::unpack_value_array_3(ctx, v542);

14641

                            let v556 = constructor_all_ones_or_all_zeros(ctx, v543.0);

14642

                            if let Some(v557) = v556 {

14643

                                let v547 = constructor_put_in_xmm(ctx, v543.0);

14644

                                let v558 = &C::put_in_xmm_mem(ctx, v543.1);

14645

                                let v559 = constructor_put_in_xmm(ctx, v543.2);

14646

                                let v560 = constructor_x64_blend(ctx, v3, v547, v558, v559);

14647

                                let v561 = constructor_output_xmm(ctx, v560);

14648

                                // Rule at src/isa/x64/lower.isle line 1205.

14649

                                return Some(v561);

14650

14651

                            let v547 = constructor_put_in_xmm(ctx, v543.0);

14652

                            let v548 = constructor_put_in_xmm(ctx, v543.1);

14653

                            let v549 = &C::xmm_to_xmm_mem(ctx, v547);

14654

                            let v550 = constructor_sse_and(ctx, v3, v548, v549);

14655

                            let v551 = &C::put_in_xmm_mem(ctx, v543.2);

14656

                            let v552 = constructor_sse_and_not(ctx, v3, v547, v551);

14657

                            let v553 = &C::xmm_to_xmm_mem(ctx, v550);

14658

                            let v554 = constructor_sse_or(ctx, v3, v552, v553);

14659

                            let v555 = constructor_output_xmm(ctx, v554);

14660

                            // Rule at src/isa/x64/lower.isle line 1191.

14661

                            return Some(v555);

14662

14663

14664

14665

                &Opcode::X86Blendv => {

14666

                    let v1 = C::first_result(ctx, arg0);

14667

                    if let Some(v2) = v1 {

14668

                        let v3 = C::value_type(ctx, v2);

14669

                        match v3 {

14670

                            I8X16 => {

14671

                                let v543 = C::unpack_value_array_3(ctx, v542);

14672

                                let v562 = constructor_put_in_xmm(ctx, v543.2);

14673

                                let v558 = &C::put_in_xmm_mem(ctx, v543.1);

14674

                                let v563 = constructor_put_in_xmm(ctx, v543.0);

14675

                                let v564 = constructor_x64_pblendvb(ctx, v562, v558, v563);

14676

                                let v565 = constructor_output_xmm(ctx, v564);

14677

                                // Rule at src/isa/x64/lower.isle line 1225.

14678

                                return Some(v565);

14679

14680

                            I32X4 => {

14681

                                let v543 = C::unpack_value_array_3(ctx, v542);

14682

                                let v562 = constructor_put_in_xmm(ctx, v543.2);

14683

                                let v558 = &C::put_in_xmm_mem(ctx, v543.1);

14684

                                let v563 = constructor_put_in_xmm(ctx, v543.0);

14685

                                let v566 = constructor_x64_blendvps(ctx, v562, v558, v563);

14686

                                let v567 = constructor_output_xmm(ctx, v566);

14687

                                // Rule at src/isa/x64/lower.isle line 1229.

14688

                                return Some(v567);

14689

14690

                            I64X2 => {

14691

                                let v543 = C::unpack_value_array_3(ctx, v542);

14692

                                let v562 = constructor_put_in_xmm(ctx, v543.2);

14693

                                let v558 = &C::put_in_xmm_mem(ctx, v543.1);

14694

                                let v563 = constructor_put_in_xmm(ctx, v543.0);

14695

                                let v568 = constructor_x64_blendvpd(ctx, v562, v558, v563);

14696

                                let v569 = constructor_output_xmm(ctx, v568);

14697

                                // Rule at src/isa/x64/lower.isle line 1233.

14698

                                return Some(v569);

14699

14700

                            _ => {}

14701

14702

14703

14704

                &Opcode::Fma => {

14705

                    let v1 = C::first_result(ctx, arg0);

14706

                    if let Some(v2) = v1 {

14707

                        let v1248 = C::use_fma(ctx);

14708

                        if v1248 == true {

14709

                            let v3 = C::value_type(ctx, v2);

14710

                            let v543 = C::unpack_value_array_3(ctx, v542);

14711

                            let v1249 = constructor_fmadd(ctx, v3, v543.0, v543.1, v543.2);

14712

                            let v1250 = constructor_output_xmm(ctx, v1249);

14713

                            // Rule at src/isa/x64/lower.isle line 2361.

14714

                            return Some(v1250);

14715

14716

                        let v3 = C::value_type(ctx, v2);

14717

                        match v3 {

14718

                            F32 => {

14719

                                let v543 = C::unpack_value_array_3(ctx, v542);

14720

                                let v1169 = C::put_in_reg(ctx, v543.0);

14721

                                let v1170 = C::put_in_reg(ctx, v543.1);

14722

                                let v1171 = C::put_in_reg(ctx, v543.2);

14723

                                let v1172 =

14724

                                    C::libcall_3(ctx, &LibCall::FmaF32, v1169, v1170, v1171);

14725

                                let v1173 = constructor_output_reg(ctx, v1172);

14726

                                // Rule at src/isa/x64/lower.isle line 2316.

14727

                                return Some(v1173);

14728

14729

                            F64 => {

14730

                                let v543 = C::unpack_value_array_3(ctx, v542);

14731

                                let v1169 = C::put_in_reg(ctx, v543.0);

14732

                                let v1170 = C::put_in_reg(ctx, v543.1);

14733

                                let v1171 = C::put_in_reg(ctx, v543.2);

14734

                                let v1175 =

14735

                                    C::libcall_3(ctx, &LibCall::FmaF64, v1169, v1170, v1171);

14736

                                let v1176 = constructor_output_reg(ctx, v1175);

14737

                                // Rule at src/isa/x64/lower.isle line 2318.

14738

                                return Some(v1176);

14739

14740

                            F32X4 => {

14741

                                let v543 = C::unpack_value_array_3(ctx, v542);

14742

                                let v547 = constructor_put_in_xmm(ctx, v543.0);

14743

                                let v548 = constructor_put_in_xmm(ctx, v543.1);

14744

                                let v559 = constructor_put_in_xmm(ctx, v543.2);

14745

                                let v1177 = C::xmm_to_reg(ctx, v547);

14746

                                let v1178 = C::xmm_to_reg(ctx, v548);

14747

                                let v1179 = C::xmm_to_reg(ctx, v559);

14748

                                let v1180 =

14749

                                    C::libcall_3(ctx, &LibCall::FmaF32, v1177, v1178, v1179);

14750

                                let v1181 = C::xmm_new(ctx, v1180);

14751

                                let v1182 = &C::xmm_to_xmm_mem(ctx, v547);

14752

                                let v1183 = constructor_x64_pshufd(ctx, v1182, 0x1);

14753

                                let v1184 = C::xmm_to_reg(ctx, v1183);

14754

                                let v1185 = &C::xmm_to_xmm_mem(ctx, v548);

14755

                                let v1186 = constructor_x64_pshufd(ctx, v1185, 0x1);

14756

                                let v1187 = C::xmm_to_reg(ctx, v1186);

14757

                                let v1188 = &C::xmm_to_xmm_mem(ctx, v559);

14758

                                let v1189 = constructor_x64_pshufd(ctx, v1188, 0x1);

14759

                                let v1190 = C::xmm_to_reg(ctx, v1189);

14760

                                let v1191 =

14761

                                    C::libcall_3(ctx, &LibCall::FmaF32, v1184, v1187, v1190);

14762

                                let v1192 = C::xmm_new(ctx, v1191);

14763

                                let v1193 = &C::xmm_to_xmm_mem(ctx, v547);

14764

                                let v1195 = constructor_x64_pshufd(ctx, v1193, 0x2);

14765

                                let v1196 = C::xmm_to_reg(ctx, v1195);

14766

                                let v1197 = &C::xmm_to_xmm_mem(ctx, v548);

14767

                                let v1198 = constructor_x64_pshufd(ctx, v1197, 0x2);

14768

                                let v1199 = C::xmm_to_reg(ctx, v1198);

14769

                                let v1200 = &C::xmm_to_xmm_mem(ctx, v559);

14770

                                let v1201 = constructor_x64_pshufd(ctx, v1200, 0x2);

14771

                                let v1202 = C::xmm_to_reg(ctx, v1201);

14772

                                let v1203 =

14773

                                    C::libcall_3(ctx, &LibCall::FmaF32, v1196, v1199, v1202);

14774

                                let v1204 = C::xmm_new(ctx, v1203);

14775

                                let v1205 = &C::xmm_to_xmm_mem(ctx, v547);

14776

                                let v1207 = constructor_x64_pshufd(ctx, v1205, 0x3);

14777

                                let v1208 = C::xmm_to_reg(ctx, v1207);

14778

                                let v1209 = &C::xmm_to_xmm_mem(ctx, v548);

14779

                                let v1210 = constructor_x64_pshufd(ctx, v1209, 0x3);

14780

                                let v1211 = C::xmm_to_reg(ctx, v1210);

14781

                                let v1212 = &C::xmm_to_xmm_mem(ctx, v559);

14782

                                let v1213 = constructor_x64_pshufd(ctx, v1212, 0x3);

14783

                                let v1214 = C::xmm_to_reg(ctx, v1213);

14784

                                let v1215 =

14785

                                    C::libcall_3(ctx, &LibCall::FmaF32, v1208, v1211, v1214);

14786

                                let v1216 = C::xmm_new(ctx, v1215);

14787

                                let v1218 = C::xmm_to_reg(ctx, v1192);

14788

                                let v1219 = &constructor_xmm_to_reg_mem(ctx, v1218);

14789

                                let v1220 = &C::xmm_mem_to_reg_mem(ctx, v1219);

14790

                                let v1221 =

14791

                                    constructor_vec_insert_lane(ctx, F32X4, v1181, v1220, 0x1);

14792

                                let v1222 = C::xmm_to_reg(ctx, v1204);

14793

                                let v1223 = &constructor_xmm_to_reg_mem(ctx, v1222);

14794

                                let v1224 = &C::xmm_mem_to_reg_mem(ctx, v1223);

14795

                                let v1225 =

14796

                                    constructor_vec_insert_lane(ctx, F32X4, v1221, v1224, 0x2);

14797

                                let v1226 = C::xmm_to_reg(ctx, v1216);

14798

                                let v1227 = &constructor_xmm_to_reg_mem(ctx, v1226);

14799

                                let v1228 = &C::xmm_mem_to_reg_mem(ctx, v1227);

14800

                                let v1229 =

14801

                                    constructor_vec_insert_lane(ctx, F32X4, v1225, v1228, 0x3);

14802

                                let v1230 = constructor_output_xmm(ctx, v1229);

14803

                                // Rule at src/isa/x64/lower.isle line 2321.

14804

                                return Some(v1230);

14805

14806

                            F64X2 => {

14807

                                let v543 = C::unpack_value_array_3(ctx, v542);

14808

                                let v547 = constructor_put_in_xmm(ctx, v543.0);

14809

                                let v548 = constructor_put_in_xmm(ctx, v543.1);

14810

                                let v559 = constructor_put_in_xmm(ctx, v543.2);

14811

                                let v1177 = C::xmm_to_reg(ctx, v547);

14812

                                let v1178 = C::xmm_to_reg(ctx, v548);

14813

                                let v1179 = C::xmm_to_reg(ctx, v559);

14814

                                let v1231 =

14815

                                    C::libcall_3(ctx, &LibCall::FmaF64, v1177, v1178, v1179);

14816

                                let v1232 = C::xmm_new(ctx, v1231);

14817

                                let v1182 = &C::xmm_to_xmm_mem(ctx, v547);

14818

                                let v1234 = constructor_x64_pshufd(ctx, v1182, 0xEE);

14819

                                let v1235 = C::xmm_to_reg(ctx, v1234);

14820

                                let v1185 = &C::xmm_to_xmm_mem(ctx, v548);

14821

                                let v1236 = constructor_x64_pshufd(ctx, v1185, 0xEE);

14822

                                let v1237 = C::xmm_to_reg(ctx, v1236);

14823

                                let v1188 = &C::xmm_to_xmm_mem(ctx, v559);

14824

                                let v1238 = constructor_x64_pshufd(ctx, v1188, 0xEE);

14825

                                let v1239 = C::xmm_to_reg(ctx, v1238);

14826

                                let v1240 =

14827

                                    C::libcall_3(ctx, &LibCall::FmaF64, v1235, v1237, v1239);

14828

                                let v1241 = C::xmm_new(ctx, v1240);

14829

                                let v1243 = C::xmm_to_reg(ctx, v1241);

14830

                                let v1244 = &constructor_xmm_to_reg_mem(ctx, v1243);

14831

                                let v1245 = &C::xmm_mem_to_reg_mem(ctx, v1244);

14832

                                let v1246 =

14833

                                    constructor_vec_insert_lane(ctx, F64X2, v1232, v1245, 0x1);

14834

                                let v1247 = constructor_output_xmm(ctx, v1246);

14835

                                // Rule at src/isa/x64/lower.isle line 2345.

14836

                                return Some(v1247);

14837

14838

                            _ => {}

14839

14840

14841

14842

                _ => {}

14843

14844

14845

        &InstructionData::TernaryImm8 {

14846

            opcode: ref v570,

14847

            args: ref v571,

14848

            imm: v572,

14849

        } => {

14850

            if let &Opcode::Insertlane = v570 {

14851

                let v573 = C::unpack_value_array_2(ctx, v571);

14852

                let v578 = constructor_put_in_xmm(ctx, v573.0);

14853

                let v579 = &C::put_in_reg_mem(ctx, v573.1);

14854

                let v576 = C::value_type(ctx, v573.0);

14855

                let v577 = C::u8_from_uimm8(ctx, v572);

14856

                let v580 = constructor_vec_insert_lane(ctx, v576, v578, v579, v577);

14857

                let v581 = constructor_output_xmm(ctx, v580);

14858

                // Rule at src/isa/x64/lower.isle line 1239.

14859

                return Some(v581);

14860

14861

14862

        &InstructionData::Trap {

14863

            opcode: ref v618,

14864

            code: ref v619,

14865

        } => {

14866

            match v618 {

14867

                &Opcode::Trap => {

14868

                    let v620 = &constructor_x64_ud2(ctx, v619);

14869

                    let v621 = constructor_side_effect(ctx, v620);

14870

                    // Rule at src/isa/x64/lower.isle line 1365.

14871

                    return Some(v621);

14872

14873

                &Opcode::ResumableTrap => {

14874

                    let v620 = &constructor_x64_ud2(ctx, v619);

14875

                    let v621 = constructor_side_effect(ctx, v620);

14876

                    // Rule at src/isa/x64/lower.isle line 1392.

14877

                    return Some(v621);

14878

14879

                _ => {}

14880

14881

14882

        &InstructionData::Unary {

14883

            opcode: ref v300,

14884

            arg: v301,

14885

        } => {

14886

            match v300 {

14887

                &Opcode::Splat => {

14888

                    let v1 = C::first_result(ctx, arg0);

14889

                    if let Some(v2) = v1 {

14890

                        let v3 = C::value_type(ctx, v2);

14891

                        let v64 = C::multi_lane(ctx, v3);

14892

                        if let Some(v65) = v64 {

14893

                            match v65.0 {

14894

                                0x20 => {

14895

                                    if v65.1 == 0x4 {

14896

                                        let v2109 = &C::sinkable_load(ctx, v301);

14897

                                        if let Some(v2110) = v2109 {

14898

                                            let v2167 = C::use_avx_simd(ctx);

14899

                                            if v2167 == true {

14900

                                                let v2168 =

14901

                                                    &constructor_sink_load_to_xmm_mem(ctx, v2110);

14902

                                                let v2169 =

14903

                                                    constructor_x64_vbroadcastss(ctx, v2168);

14904

                                                let v2170 = constructor_output_xmm(ctx, v2169);

14905

                                                // Rule at src/isa/x64/lower.isle line 3843.

14906

                                                return Some(v2170);

14907

14908

                                            let v2113 = &C::sink_load(ctx, v2110);

14909

                                            let v2114 = constructor_x64_movss_load(ctx, v2113);

14910

                                            let v2164 = &C::xmm_to_xmm_mem(ctx, v2114);

14911

                                            let v2165 =

14912

                                                constructor_x64_shufps(ctx, v2114, v2164, 0x0);

14913

                                            let v2166 = constructor_output_xmm(ctx, v2165);

14914

                                            // Rule at src/isa/x64/lower.isle line 3840.

14915

                                            return Some(v2166);

14916

14917

14918

14919

                                0x40 => {

14920

                                    if v65.1 == 0x2 {

14921

                                        let v2109 = &C::sinkable_load(ctx, v301);

14922

                                        if let Some(v2110) = v2109 {

14923

                                            let v2168 =

14924

                                                &constructor_sink_load_to_xmm_mem(ctx, v2110);

14925

                                            let v2177 = constructor_x64_movddup(ctx, v2168);

14926

                                            let v2178 = constructor_output_xmm(ctx, v2177);

14927

                                            // Rule at src/isa/x64/lower.isle line 3854.

14928

                                            return Some(v2178);

14929

14930

14931

14932

                                _ => {}

14933

14934

14935

                        match v3 {

14936

                            I8X16 => {

14937

                                let v2129 = &C::sinkable_load_exact(ctx, v301);

14938

                                if let Some(v2130) = v2129 {

14939

                                    let v2125 = C::use_avx2_simd(ctx);

14940

                                    if v2125 == true {

14941

                                        let v2138 = &constructor_sink_load_to_xmm_mem(ctx, v2130);

14942

                                        let v2139 = constructor_x64_vpbroadcastb(ctx, v2138);

14943

                                        let v2140 = constructor_output_xmm(ctx, v2139);

14944

                                        // Rule at src/isa/x64/lower.isle line 3791.

14945

                                        return Some(v2140);

14946

14947

                                    let v2131 = constructor_xmm_uninit_value(ctx);

14948

                                    let v2132 = &constructor_sink_load_to_gpr_mem(ctx, v2130);

14949

                                    let v2133 = constructor_x64_pinsrb(ctx, v2131, v2132, 0x0);

14950

                                    let v2134 = constructor_xmm_zero(ctx, I8X16);

14951

                                    let v2135 = &C::xmm_to_xmm_mem(ctx, v2134);

14952

                                    let v2136 = constructor_x64_pshufb(ctx, v2133, v2135);

14953

                                    let v2137 = constructor_output_xmm(ctx, v2136);

14954

                                    // Rule at src/isa/x64/lower.isle line 3789.

14955

                                    return Some(v2137);

14956

14957

                                let v2125 = C::use_avx2_simd(ctx);

14958

                                if v2125 == true {

14959

                                    let v302 = constructor_put_in_gpr(ctx, v301);

14960

                                    let v2120 = constructor_bitcast_gpr_to_xmm(ctx, I32, v302);

14961

                                    let v2126 = &C::xmm_to_xmm_mem(ctx, v2120);

14962

                                    let v2127 = constructor_x64_vpbroadcastb(ctx, v2126);

14963

                                    let v2128 = constructor_output_xmm(ctx, v2127);

14964

                                    // Rule at src/isa/x64/lower.isle line 3786.

14965

                                    return Some(v2128);

14966

14967

                                let v302 = constructor_put_in_gpr(ctx, v301);

14968

                                let v2120 = constructor_bitcast_gpr_to_xmm(ctx, I32, v302);

14969

                                let v2121 = constructor_xmm_zero(ctx, I8X16);

14970

                                let v2122 = &C::xmm_to_xmm_mem(ctx, v2121);

14971

                                let v2123 = constructor_x64_pshufb(ctx, v2120, v2122);

14972

                                let v2124 = constructor_output_xmm(ctx, v2123);

14973

                                // Rule at src/isa/x64/lower.isle line 3784.

14974

                                return Some(v2124);

14975

14976

                            I16X8 => {

14977

                                let v2129 = &C::sinkable_load_exact(ctx, v301);

14978

                                if let Some(v2130) = v2129 {

14979

                                    let v2125 = C::use_avx2_simd(ctx);

14980

                                    if v2125 == true {

14981

                                        let v2138 = &constructor_sink_load_to_xmm_mem(ctx, v2130);

14982

                                        let v2153 = constructor_x64_vpbroadcastw(ctx, v2138);

14983

                                        let v2154 = constructor_output_xmm(ctx, v2153);

14984

                                        // Rule at src/isa/x64/lower.isle line 3807.

14985

                                        return Some(v2154);

14986

14987

                                    let v2131 = constructor_xmm_uninit_value(ctx);

14988

                                    let v2132 = &constructor_sink_load_to_gpr_mem(ctx, v2130);

14989

                                    let v2147 = constructor_x64_pinsrw(ctx, v2131, v2132, 0x0);

14990

                                    let v2148 = &C::xmm_to_xmm_mem(ctx, v2147);

14991

                                    let v2149 = constructor_x64_pshuflw(ctx, v2148, 0x0);

14992

                                    let v2150 = &C::xmm_to_xmm_mem(ctx, v2149);

14993

                                    let v2151 = constructor_x64_pshufd(ctx, v2150, 0x0);

14994

                                    let v2152 = constructor_output_xmm(ctx, v2151);

14995

                                    // Rule at src/isa/x64/lower.isle line 3805.

14996

                                    return Some(v2152);

14997

14998

                                let v2125 = C::use_avx2_simd(ctx);

14999

                                if v2125 == true {

15000

                                    let v302 = constructor_put_in_gpr(ctx, v301);

15001

                                    let v2120 = constructor_bitcast_gpr_to_xmm(ctx, I32, v302);

15002

                                    let v2126 = &C::xmm_to_xmm_mem(ctx, v2120);

15003

                                    let v2145 = constructor_x64_vpbroadcastw(ctx, v2126);

15004

                                    let v2146 = constructor_output_xmm(ctx, v2145);

15005

                                    // Rule at src/isa/x64/lower.isle line 3802.

15006

                                    return Some(v2146);

15007

15008

                                let v302 = constructor_put_in_gpr(ctx, v301);

15009

                                let v2120 = constructor_bitcast_gpr_to_xmm(ctx, I32, v302);

15010

                                let v2126 = &C::xmm_to_xmm_mem(ctx, v2120);

15011

                                let v2141 = constructor_x64_pshuflw(ctx, v2126, 0x0);

15012

                                let v2142 = &C::xmm_to_xmm_mem(ctx, v2141);

15013

                                let v2143 = constructor_x64_pshufd(ctx, v2142, 0x0);

15014

                                let v2144 = constructor_output_xmm(ctx, v2143);

15015

                                // Rule at src/isa/x64/lower.isle line 3800.

15016

                                return Some(v2144);

15017

15018

                            I32X4 => {

15019

                                let v2125 = C::use_avx2_simd(ctx);

15020

                                if v2125 == true {

15021

                                    let v302 = constructor_put_in_gpr(ctx, v301);

15022

                                    let v2120 = constructor_bitcast_gpr_to_xmm(ctx, I32, v302);

15023

                                    let v2126 = &C::xmm_to_xmm_mem(ctx, v2120);

15024

                                    let v2157 = constructor_x64_vpbroadcastd(ctx, v2126);

15025

                                    let v2158 = constructor_output_xmm(ctx, v2157);

15026

                                    // Rule at src/isa/x64/lower.isle line 3817.

15027

                                    return Some(v2158);

15028

15029

                                let v302 = constructor_put_in_gpr(ctx, v301);

15030

                                let v2120 = constructor_bitcast_gpr_to_xmm(ctx, I32, v302);

15031

                                let v2126 = &C::xmm_to_xmm_mem(ctx, v2120);

15032

                                let v2155 = constructor_x64_pshufd(ctx, v2126, 0x0);

15033

                                let v2156 = constructor_output_xmm(ctx, v2155);

15034

                                // Rule at src/isa/x64/lower.isle line 3815.

15035

                                return Some(v2156);

15036

15037

                            I64X2 => {

15038

                                let v302 = constructor_put_in_gpr(ctx, v301);

15039

                                let v2171 = constructor_bitcast_gpr_to_xmm(ctx, I64, v302);

15040

                                let v2172 = &C::xmm_to_xmm_mem(ctx, v2171);

15041

                                let v2173 = constructor_x64_movddup(ctx, v2172);

15042

                                let v2174 = constructor_output_xmm(ctx, v2173);

15043

                                // Rule at src/isa/x64/lower.isle line 3850.

15044

                                return Some(v2174);

15045

15046

                            F32X4 => {

15047

                                let v2125 = C::use_avx2_simd(ctx);

15048

                                if v2125 == true {

15049

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

15050

                                    let v2162 = constructor_x64_vbroadcastss(ctx, v459);

15051

                                    let v2163 = constructor_output_xmm(ctx, v2162);

15052

                                    // Rule at src/isa/x64/lower.isle line 3827.

15053

                                    return Some(v2163);

15054

15055

                                let v469 = constructor_put_in_xmm(ctx, v301);

15056

                                let v2159 = constructor_put_in_xmm(ctx, v301);

15057

                                let v317 = &C::put_in_xmm_mem(ctx, v301);

15058

                                let v2160 = constructor_x64_shufps(ctx, v2159, v317, 0x0);

15059

                                let v2161 = constructor_output_xmm(ctx, v2160);

15060

                                // Rule at src/isa/x64/lower.isle line 3824.

15061

                                return Some(v2161);

15062

15063

                            F64X2 => {

15064

                                let v459 = &C::put_in_xmm_mem(ctx, v301);

15065

                                let v2175 = constructor_x64_movddup(ctx, v459);

15066

                                let v2176 = constructor_output_xmm(ctx, v2175);

15067

                                // Rule at src/isa/x64/lower.isle line 3852.

15068

                                return Some(v2176);

15069

15070

                            _ => {}

15071

15072

15073

15074

                &Opcode::SetPinnedReg => {

15075

                    let v302 = constructor_put_in_gpr(ctx, v301);

15076

                    let v1960 = &constructor_write_pinned_gpr(ctx, v302);

15077

                    let v1961 = constructor_side_effect(ctx, v1960);

15078

                    // Rule at src/isa/x64/lower.isle line 3543.

15079

                    return Some(v1961);

15080

15081

                &Opcode::VanyTrue => {

15082

                    let v469 = constructor_put_in_xmm(ctx, v301);

15083

                    let v1075 = &C::xmm_to_xmm_mem(ctx, v469);

15084

                    let v2179 = &constructor_x64_ptest(ctx, v1075, v469);

15085

                    let v2180 = &constructor_x64_setcc(ctx, &CC::NZ);

15086

                    let v2181 = constructor_with_flags(ctx, v2179, v2180);

15087

                    let v2182 = C::output(ctx, v2181);

15088

                    // Rule at src/isa/x64/lower.isle line 3859.

15089

                    return Some(v2182);

15090

15091

                &Opcode::VallTrue => {

15092

                    let v469 = constructor_put_in_xmm(ctx, v301);

15093

                    let v529 = C::value_type(ctx, v301);

15094

                    let v2183 = constructor_xmm_zero(ctx, v529);

15095

                    let v2184 = constructor_vec_int_type(ctx, v529);

15096

                    let v2185 = &C::xmm_to_xmm_mem(ctx, v2183);

15097

                    let v2186 = constructor_x64_pcmpeq(ctx, v2184, v469, v2185);

15098

                    let v2187 = &C::xmm_to_xmm_mem(ctx, v2186);

15099

                    let v2188 = &constructor_x64_ptest(ctx, v2187, v2186);

15100

                    let v2189 = &constructor_x64_setcc(ctx, &CC::Z);

15101

                    let v2190 = constructor_with_flags(ctx, v2188, v2189);

15102

                    let v2191 = C::output(ctx, v2190);

15103

                    // Rule at src/isa/x64/lower.isle line 3865.

15104

                    return Some(v2191);

15105

15106

                &Opcode::VhighBits => {

15107

                    let v529 = C::value_type(ctx, v301);

15108

                    let v2192 = C::multi_lane(ctx, v529);

15109

                    if let Some(v2193) = v2192 {

15110

                        match v2193.0 {

15111

                            0x8 => {

15112

                                if v2193.1 == 0x10 {

15113

                                    let v469 = constructor_put_in_xmm(ctx, v301);

15114

                                    let v2197 =

15115

                                        constructor_x64_pmovmskb(ctx, &OperandSize::Size32, v469);

15116

                                    let v2198 = constructor_output_gpr(ctx, v2197);

15117

                                    // Rule at src/isa/x64/lower.isle line 3882.

15118

                                    return Some(v2198);

15119

15120

15121

                            0x10 => {

15122

                                if v2193.1 == 0x8 {

15123

                                    let v469 = constructor_put_in_xmm(ctx, v301);

15124

                                    let v1075 = &C::xmm_to_xmm_mem(ctx, v469);

15125

                                    let v2203 = constructor_x64_packsswb(ctx, v469, v1075);

15126

                                    let v2204 =

15127

                                        constructor_x64_pmovmskb(ctx, &OperandSize::Size32, v2203);

15128

                                    let v968 = Imm8Reg::Imm8 { imm: 0x8 };

15129

                                    let v1909 = &C::imm8_reg_to_imm8_gpr(ctx, &v968);

15130

                                    let v2205 = constructor_x64_shr(ctx, I64, v2204, v1909);

15131

                                    let v2206 = constructor_output_gpr(ctx, v2205);

15132

                                    // Rule at src/isa/x64/lower.isle line 3897.

15133

                                    return Some(v2206);

15134

15135

15136

                            0x20 => {

15137

                                if v2193.1 == 0x4 {

15138

                                    let v469 = constructor_put_in_xmm(ctx, v301);

15139

                                    let v2199 =

15140

                                        constructor_x64_movmskps(ctx, &OperandSize::Size32, v469);

15141

                                    let v2200 = constructor_output_gpr(ctx, v2199);

15142

                                    // Rule at src/isa/x64/lower.isle line 3885.

15143

                                    return Some(v2200);

15144

15145

15146

                            0x40 => {

15147

                                if v2193.1 == 0x2 {

15148

                                    let v469 = constructor_put_in_xmm(ctx, v301);

15149

                                    let v2201 =

15150

                                        constructor_x64_movmskpd(ctx, &OperandSize::Size32, v469);

15151

                                    let v2202 = constructor_output_gpr(ctx, v2201);

15152

                                    // Rule at src/isa/x64/lower.isle line 3888.

15153

                                    return Some(v2202);

15154

15155

15156

                            _ => {}

15157

15158

15159

15160

                &Opcode::Ineg => {

15161

                    let v1 = C::first_result(ctx, arg0);

15162

                    if let Some(v2) = v1 {

15163

                        let v3 = C::value_type(ctx, v2);

15164

                        match v3 {

15165

                            I8X16 => {

15166

                                let v315 = constructor_imm(ctx, I8X16, 0x0);

15167

                                let v316 = C::xmm_new(ctx, v315);

15168

                                let v317 = &C::put_in_xmm_mem(ctx, v301);

15169

                                let v318 = constructor_x64_psubb(ctx, v316, v317);

15170

                                let v319 = constructor_output_xmm(ctx, v318);

15171

                                // Rule at src/isa/x64/lower.isle line 765.

15172

                                return Some(v319);

15173

15174

                            I16X8 => {

15175

                                let v321 = constructor_imm(ctx, I16X8, 0x0);

15176

                                let v322 = C::xmm_new(ctx, v321);

15177

                                let v317 = &C::put_in_xmm_mem(ctx, v301);

15178

                                let v323 = constructor_x64_psubw(ctx, v322, v317);

15179

                                let v324 = constructor_output_xmm(ctx, v323);

15180

                                // Rule at src/isa/x64/lower.isle line 768.

15181

                                return Some(v324);

15182

15183

                            I32X4 => {

15184

                                let v326 = constructor_imm(ctx, I32X4, 0x0);

15185

                                let v327 = C::xmm_new(ctx, v326);

15186

                                let v317 = &C::put_in_xmm_mem(ctx, v301);

15187

                                let v328 = constructor_x64_psubd(ctx, v327, v317);

15188

                                let v329 = constructor_output_xmm(ctx, v328);

15189

                                // Rule at src/isa/x64/lower.isle line 771.

15190

                                return Some(v329);

15191

15192

                            I64X2 => {

15193

                                let v331 = constructor_imm(ctx, I64X2, 0x0);

15194

                                let v332 = C::xmm_new(ctx, v331);

15195

                                let v317 = &C::put_in_xmm_mem(ctx, v301);

15196

                                let v333 = constructor_x64_psubq(ctx, v332, v317);

15197

                                let v334 = constructor_output_xmm(ctx, v333);

15198

                                // Rule at src/isa/x64/lower.isle line 774.

15199

                                return Some(v334);

15200

15201

                            _ => {}

15202

15203

                        let v4 = C::fits_in_64(ctx, v3);

15204

                        if let Some(v5) = v4 {

15205

                            let v302 = constructor_put_in_gpr(ctx, v301);

15206

                            let v303 = constructor_x64_neg(ctx, v5, v302);

15207

                            let v304 = constructor_output_gpr(ctx, v303);

15208

                            // Rule at src/isa/x64/lower.isle line 751.

15209

                            return Some(v304);

15210

15211

                        if v3 == I128 {

15212

                            let v305 = C::put_in_regs(ctx, v301);

15213

                            let v306 = constructor_value_regs_get_gpr(ctx, v305, 0x0);

15214

                            let v307 = constructor_value_regs_get_gpr(ctx, v305, 0x1);

15215

                            let v308 = &constructor_x64_neg_paired(ctx, I64, v306);

15216

                            let v309 = constructor_imm(ctx, I64, 0x0);

15217

                            let v310 = C::gpr_new(ctx, v309);

15218

                            let v311 = &C::gpr_to_gpr_mem_imm(ctx, v307);

15219

                            let v312 = &constructor_x64_sbb_paired(ctx, I64, v310, v311);

15220

                            let v313 = constructor_with_flags(ctx, v308, v312);

15221

                            let v314 = C::output(ctx, v313);

15222

                            // Rule at src/isa/x64/lower.isle line 754.

15223

                            return Some(v314);

15224

15225

15226

15227

                &Opcode::Iabs => {

15228

                    let v1 = C::first_result(ctx, arg0);

15229

                    if let Some(v2) = v1 {

15230

                        let v3 = C::value_type(ctx, v2);

15231

                        match v3 {

15232

                            I8X16 => {

15233

                                let v459 = &C::put_in_xmm_mem(ctx, v301);

15234

                                let v460 = constructor_x64_pabsb(ctx, v459);

15235

                                let v461 = constructor_output_xmm(ctx, v460);

15236

                                // Rule at src/isa/x64/lower.isle line 1040.

15237

                                return Some(v461);

15238

15239

                            I16X8 => {

15240

                                let v459 = &C::put_in_xmm_mem(ctx, v301);

15241

                                let v462 = constructor_x64_pabsw(ctx, v459);

15242

                                let v463 = constructor_output_xmm(ctx, v462);

15243

                                // Rule at src/isa/x64/lower.isle line 1043.

15244

                                return Some(v463);

15245

15246

                            I32X4 => {

15247

                                let v459 = &C::put_in_xmm_mem(ctx, v301);

15248

                                let v464 = constructor_x64_pabsd(ctx, v459);

15249

                                let v465 = constructor_output_xmm(ctx, v464);

15250

                                // Rule at src/isa/x64/lower.isle line 1046.

15251

                                return Some(v465);

15252

15253

                            I64X2 => {

15254

                                let v363 = C::avx512vl_enabled(ctx, v3);

15255

                                if v363 == true {

15256

                                    let v466 = C::avx512f_enabled(ctx, v3);

15257

                                    if v466 == true {

15258

                                        let v459 = &C::put_in_xmm_mem(ctx, v301);

15259

                                        let v467 = constructor_x64_vpabsq(ctx, v459);

15260

                                        let v468 = constructor_output_xmm(ctx, v467);

15261

                                        // Rule at src/isa/x64/lower.isle line 1050.

15262

                                        return Some(v468);

15263

15264

15265

                                let v469 = constructor_put_in_xmm(ctx, v301);

15266

                                let v470 = constructor_imm(ctx, I64X2, 0x0);

15267

                                let v471 = C::xmm_new(ctx, v470);

15268

                                let v472 = &C::xmm_to_xmm_mem(ctx, v469);

15269

                                let v473 = constructor_x64_psubq(ctx, v471, v472);

15270

                                let v474 = &C::xmm_to_xmm_mem(ctx, v469);

15271

                                let v475 = constructor_x64_blendvpd(ctx, v473, v474, v473);

15272

                                let v476 = constructor_output_xmm(ctx, v475);

15273

                                // Rule at src/isa/x64/lower.isle line 1060.

15274

                                return Some(v476);

15275

15276

                            _ => {}

15277

15278

                        let v4 = C::fits_in_64(ctx, v3);

15279

                        if let Some(v5) = v4 {

15280

                            let v302 = constructor_put_in_gpr(ctx, v301);

15281

                            let v477 = &constructor_x64_neg_paired(ctx, v5, v302);

15282

                            let v478 = constructor_produces_flags_get_reg(ctx, v477);

15283

                            let v479 = C::gpr_new(ctx, v478);

15284

                            let v481 = &C::gpr_to_gpr_mem(ctx, v302);

15285

                            let v482 = &constructor_cmove(ctx, v5, &CC::S, v481, v479);

15286

                            let v483 = &constructor_produces_flags_ignore(ctx, v477);

15287

                            let v484 = constructor_with_flags_reg(ctx, v483, v482);

15288

                            let v485 = constructor_output_reg(ctx, v484);

15289

                            // Rule at src/isa/x64/lower.isle line 1067.

15290

                            return Some(v485);

15291

15292

15293

15294

                &Opcode::Bnot => {

15295

                    let v1 = C::first_result(ctx, arg0);

15296

                    if let Some(v2) = v1 {

15297

                        let v3 = C::value_type(ctx, v2);

15298

                        if v3 == I128 {

15299

                            let v534 = constructor_i128_not(ctx, v301);

15300

                            let v535 = C::output(ctx, v534);

15301

                            // Rule at src/isa/x64/lower.isle line 1176.

15302

                            return Some(v535);

15303

15304

                        let v64 = C::multi_lane(ctx, v3);

15305

                        if let Some(v65) = v64 {

15306

                            let v469 = constructor_put_in_xmm(ctx, v301);

15307

                            let v496 = constructor_vector_all_ones(ctx);

15308

                            let v536 = &C::xmm_to_xmm_mem(ctx, v496);

15309

                            let v539 = constructor_x64_xor_vector(ctx, v3, v469, v536);

15310

                            let v540 = constructor_output_xmm(ctx, v539);

15311

                            // Rule at src/isa/x64/lower.isle line 1186.

15312

                            return Some(v540);

15313

15314

                        let v134 = C::ty_int_ref_scalar_64(ctx, v3);

15315

                        if let Some(v135) = v134 {

15316

                            let v302 = constructor_put_in_gpr(ctx, v301);

15317

                            let v532 = constructor_x64_not(ctx, v3, v302);

15318

                            let v533 = constructor_output_gpr(ctx, v532);

15319

                            // Rule at src/isa/x64/lower.isle line 1161.

15320

                            return Some(v533);

15321

15322

                        let v144 = C::ty_scalar_float(ctx, v3);

15323

                        if let Some(v145) = v144 {

15324

                            let v469 = constructor_put_in_xmm(ctx, v301);

15325

                            let v496 = constructor_vector_all_ones(ctx);

15326

                            let v536 = &C::xmm_to_xmm_mem(ctx, v496);

15327

                            let v537 = constructor_x64_xor_vector(ctx, v145, v469, v536);

15328

                            let v538 = constructor_output_xmm(ctx, v537);

15329

                            // Rule at src/isa/x64/lower.isle line 1181.

15330

                            return Some(v538);

15331

15332

15333

15334

                &Opcode::Bitrev => {

15335

                    let v1 = C::first_result(ctx, arg0);

15336

                    if let Some(v2) = v1 {

15337

                        let v3 = C::value_type(ctx, v2);

15338

                        match v3 {

15339

                            I8 => {

15340

                                let v302 = constructor_put_in_gpr(ctx, v301);

15341

                                let v951 = constructor_do_bitrev8(ctx, I32, v302);

15342

                                let v952 = constructor_output_gpr(ctx, v951);

15343

                                // Rule at src/isa/x64/lower.isle line 1861.

15344

                                return Some(v952);

15345

15346

                            I16 => {

15347

                                let v302 = constructor_put_in_gpr(ctx, v301);

15348

                                let v953 = constructor_do_bitrev16(ctx, I32, v302);

15349

                                let v954 = constructor_output_gpr(ctx, v953);

15350

                                // Rule at src/isa/x64/lower.isle line 1864.

15351

                                return Some(v954);

15352

15353

                            I32 => {

15354

                                let v302 = constructor_put_in_gpr(ctx, v301);

15355

                                let v955 = constructor_do_bitrev32(ctx, I32, v302);

15356

                                let v956 = constructor_output_gpr(ctx, v955);

15357

                                // Rule at src/isa/x64/lower.isle line 1867.

15358

                                return Some(v956);

15359

15360

                            I64 => {

15361

                                let v302 = constructor_put_in_gpr(ctx, v301);

15362

                                let v957 = constructor_do_bitrev64(ctx, I64, v302);

15363

                                let v958 = constructor_output_gpr(ctx, v957);

15364

                                // Rule at src/isa/x64/lower.isle line 1870.

15365

                                return Some(v958);

15366

15367

                            I128 => {

15368

                                let v305 = C::put_in_regs(ctx, v301);

15369

                                let v868 = constructor_value_regs_get_gpr(ctx, v305, 0x1);

15370

                                let v959 = constructor_do_bitrev64(ctx, I64, v868);

15371

                                let v960 = C::gpr_to_reg(ctx, v959);

15372

                                let v961 = C::put_in_regs(ctx, v301);

15373

                                let v962 = constructor_value_regs_get_gpr(ctx, v961, 0x0);

15374

                                let v963 = constructor_do_bitrev64(ctx, I64, v962);

15375

                                let v964 = C::gpr_to_reg(ctx, v963);

15376

                                let v965 = C::value_regs(ctx, v960, v964);

15377

                                let v966 = C::output(ctx, v965);

15378

                                // Rule at src/isa/x64/lower.isle line 1873.

15379

                                return Some(v966);

15380

15381

                            _ => {}

15382

15383

15384

15385

                &Opcode::Clz => {

15386

                    let v1 = C::first_result(ctx, arg0);

15387

                    if let Some(v2) = v1 {

15388

                        let v3 = C::value_type(ctx, v2);

15389

                        let v45 = C::ty_32_or_64(ctx, v3);

15390

                        if let Some(v46) = v45 {

15391

                            let v858 = C::use_lzcnt(ctx, v3);

15392

                            match v858 {

15393

                                true => {

15394

                                    let v302 = constructor_put_in_gpr(ctx, v301);

15395

                                    let v859 = constructor_x64_lzcnt(ctx, v46, v302);

15396

                                    let v860 = constructor_output_gpr(ctx, v859);

15397

                                    // Rule at src/isa/x64/lower.isle line 1622.

15398

                                    return Some(v860);

15399

15400

                                false => {

15401

                                    let v302 = constructor_put_in_gpr(ctx, v301);

15402

                                    let v861 = constructor_do_clz(ctx, v46, v46, v302);

15403

                                    let v862 = constructor_output_gpr(ctx, v861);

15404

                                    // Rule at src/isa/x64/lower.isle line 1629.

15405

                                    return Some(v862);

15406

15407

                                _ => {}

15408

15409

15410

                        let v863 = C::ty_8_or_16(ctx, v3);

15411

                        if let Some(v864) = v863 {

15412

                            let v865 = constructor_extend_to_gpr(ctx, v301, I32, &ExtendKind::Zero);

15413

                            let v866 = constructor_do_clz(ctx, I32, v864, v865);

15414

                            let v867 = constructor_output_gpr(ctx, v866);

15415

                            // Rule at src/isa/x64/lower.isle line 1636.

15416

                            return Some(v867);

15417

15418

                        if v3 == I128 {

15419

                            let v305 = C::put_in_regs(ctx, v301);

15420

                            let v868 = constructor_value_regs_get_gpr(ctx, v305, 0x1);

15421

                            let v869 = constructor_do_clz(ctx, I64, I64, v868);

15422

                            let v870 = C::put_in_regs(ctx, v301);

15423

                            let v871 = constructor_value_regs_get_gpr(ctx, v870, 0x0);

15424

                            let v872 = constructor_do_clz(ctx, I64, I64, v871);

15425

                            let v874 = RegMemImm::Imm { simm32: 0x40 };

15426

                            let v875 = &C::gpr_mem_imm_new(ctx, &v874);

15427

                            let v876 = constructor_x64_add(ctx, I64, v872, v875);

15428

                            let v878 =

15429

                                &constructor_x64_cmp_imm(ctx, &OperandSize::Size64, 0x40, v869);

15430

                            let v879 = &C::gpr_to_gpr_mem(ctx, v869);

15431

                            let v880 = &constructor_cmove(ctx, I64, &CC::NZ, v879, v876);

15432

                            let v881 = constructor_with_flags_reg(ctx, v878, v880);

15433

                            let v882 = C::gpr_new(ctx, v881);

15434

                            let v883 = C::gpr_to_reg(ctx, v882);

15435

                            let v884 = constructor_imm(ctx, I64, 0x0);

15436

                            let v885 = C::value_regs(ctx, v883, v884);

15437

                            let v886 = C::output(ctx, v885);

15438

                            // Rule at src/isa/x64/lower.isle line 1641.

15439

                            return Some(v886);

15440

15441

15442

15443

                &Opcode::Ctz => {

15444

                    let v1 = C::first_result(ctx, arg0);

15445

                    if let Some(v2) = v1 {

15446

                        let v3 = C::value_type(ctx, v2);

15447

                        let v45 = C::ty_32_or_64(ctx, v3);

15448

                        if let Some(v46) = v45 {

15449

                            let v171 = C::use_bmi1(ctx, v3);

15450

                            match v171 {

15451

                                true => {

15452

                                    let v302 = constructor_put_in_gpr(ctx, v301);

15453

                                    let v887 = constructor_x64_tzcnt(ctx, v46, v302);

15454

                                    let v888 = constructor_output_gpr(ctx, v887);

15455

                                    // Rule at src/isa/x64/lower.isle line 1666.

15456

                                    return Some(v888);

15457

15458

                                false => {

15459

                                    let v302 = constructor_put_in_gpr(ctx, v301);

15460

                                    let v889 = constructor_do_ctz(ctx, v46, v46, v302);

15461

                                    let v890 = constructor_output_gpr(ctx, v889);

15462

                                    // Rule at src/isa/x64/lower.isle line 1673.

15463

                                    return Some(v890);

15464

15465

                                _ => {}

15466

15467

15468

                        let v863 = C::ty_8_or_16(ctx, v3);

15469

                        if let Some(v864) = v863 {

15470

                            let v865 = constructor_extend_to_gpr(ctx, v301, I32, &ExtendKind::Zero);

15471

                            let v891 = constructor_do_ctz(ctx, I32, v864, v865);

15472

                            let v892 = constructor_output_gpr(ctx, v891);

15473

                            // Rule at src/isa/x64/lower.isle line 1680.

15474

                            return Some(v892);

15475

15476

                        if v3 == I128 {

15477

                            let v305 = C::put_in_regs(ctx, v301);

15478

                            let v306 = constructor_value_regs_get_gpr(ctx, v305, 0x0);

15479

                            let v893 = constructor_do_ctz(ctx, I64, I64, v306);

15480

                            let v870 = C::put_in_regs(ctx, v301);

15481

                            let v894 = constructor_value_regs_get_gpr(ctx, v870, 0x1);

15482

                            let v895 = constructor_do_ctz(ctx, I64, I64, v894);

15483

                            let v874 = RegMemImm::Imm { simm32: 0x40 };

15484

                            let v875 = &C::gpr_mem_imm_new(ctx, &v874);

15485

                            let v896 = constructor_x64_add(ctx, I64, v895, v875);

15486

                            let v897 =

15487

                                &constructor_x64_cmp_imm(ctx, &OperandSize::Size64, 0x40, v893);

15488

                            let v898 = &C::gpr_to_gpr_mem(ctx, v896);

15489

                            let v899 = &constructor_cmove(ctx, I64, &CC::Z, v898, v893);

15490

                            let v900 = constructor_with_flags_reg(ctx, v897, v899);

15491

                            let v901 = C::gpr_new(ctx, v900);

15492

                            let v902 = C::gpr_to_reg(ctx, v901);

15493

                            let v884 = constructor_imm(ctx, I64, 0x0);

15494

                            let v903 = C::value_regs(ctx, v902, v884);

15495

                            let v904 = C::output(ctx, v903);

15496

                            // Rule at src/isa/x64/lower.isle line 1685.

15497

                            return Some(v904);

15498

15499

15500

15501

                &Opcode::Bswap => {

15502

                    let v1 = C::first_result(ctx, arg0);

15503

                    if let Some(v2) = v1 {

15504

                        let v3 = C::value_type(ctx, v2);

15505

                        match v3 {

15506

                            I16 => {

15507

                                let v302 = constructor_put_in_gpr(ctx, v301);

15508

                                let v968 = Imm8Reg::Imm8 { imm: 0x8 };

15509

                                let v969 = &C::imm8_reg_to_imm8_gpr(ctx, &v968);

15510

                                let v970 = constructor_x64_rotl(ctx, I16, v302, v969);

15511

                                let v971 = constructor_output_gpr(ctx, v970);

15512

                                // Rule at src/isa/x64/lower.isle line 1940.

15513

                                return Some(v971);

15514

15515

                            I32 => {

15516

                                let v302 = constructor_put_in_gpr(ctx, v301);

15517

                                let v972 = constructor_x64_bswap(ctx, I32, v302);

15518

                                let v973 = constructor_output_gpr(ctx, v972);

15519

                                // Rule at src/isa/x64/lower.isle line 1943.

15520

                                return Some(v973);

15521

15522

                            I64 => {

15523

                                let v302 = constructor_put_in_gpr(ctx, v301);

15524

                                let v974 = constructor_x64_bswap(ctx, I64, v302);

15525

                                let v975 = constructor_output_gpr(ctx, v974);

15526

                                // Rule at src/isa/x64/lower.isle line 1946.

15527

                                return Some(v975);

15528

15529

                            I128 => {

15530

                                let v305 = C::put_in_regs(ctx, v301);

15531

                                let v868 = constructor_value_regs_get_gpr(ctx, v305, 0x1);

15532

                                let v976 = constructor_x64_bswap(ctx, I64, v868);

15533

                                let v977 = C::gpr_to_reg(ctx, v976);

15534

                                let v961 = C::put_in_regs(ctx, v301);

15535

                                let v962 = constructor_value_regs_get_gpr(ctx, v961, 0x0);

15536

                                let v978 = constructor_x64_bswap(ctx, I64, v962);

15537

                                let v979 = C::gpr_to_reg(ctx, v978);

15538

                                let v980 = C::value_regs(ctx, v977, v979);

15539

                                let v981 = C::output(ctx, v980);

15540

                                // Rule at src/isa/x64/lower.isle line 1949.

15541

                                return Some(v981);

15542

15543

                            _ => {}

15544

15545

15546

15547

                &Opcode::Popcnt => {

15548

                    let v1 = C::first_result(ctx, arg0);

15549

                    if let Some(v2) = v1 {

15550

                        let v3 = C::value_type(ctx, v2);

15551

                        let v905 = C::use_popcnt(ctx, v3);

15552

                        if v905 == true {

15553

                            let v45 = C::ty_32_or_64(ctx, v3);

15554

                            if let Some(v46) = v45 {

15555

                                let v302 = constructor_put_in_gpr(ctx, v301);

15556

                                let v906 = constructor_x64_popcnt(ctx, v46, v302);

15557

                                let v907 = constructor_output_gpr(ctx, v906);

15558

                                // Rule at src/isa/x64/lower.isle line 1704.

15559

                                return Some(v907);

15560

15561

                            let v863 = C::ty_8_or_16(ctx, v3);

15562

                            if let Some(v864) = v863 {

15563

                                let v865 =

15564

                                    constructor_extend_to_gpr(ctx, v301, I32, &ExtendKind::Zero);

15565

                                let v908 = constructor_x64_popcnt(ctx, I32, v865);

15566

                                let v909 = constructor_output_gpr(ctx, v908);

15567

                                // Rule at src/isa/x64/lower.isle line 1711.

15568

                                return Some(v909);

15569

15570

                            if v3 == I128 {

15571

                                let v305 = C::put_in_regs(ctx, v301);

15572

                                let v306 = constructor_value_regs_get_gpr(ctx, v305, 0x0);

15573

                                let v910 = constructor_x64_popcnt(ctx, I64, v306);

15574

                                let v870 = C::put_in_regs(ctx, v301);

15575

                                let v894 = constructor_value_regs_get_gpr(ctx, v870, 0x1);

15576

                                let v911 = constructor_x64_popcnt(ctx, I64, v894);

15577

                                let v912 = &C::gpr_to_gpr_mem_imm(ctx, v911);

15578

                                let v913 = constructor_x64_add(ctx, I64, v910, v912);

15579

                                let v914 = C::gpr_to_reg(ctx, v913);

15580

                                let v915 = constructor_imm(ctx, I64, 0x0);

15581

                                let v916 = C::value_regs(ctx, v914, v915);

15582

                                let v917 = C::output(ctx, v916);

15583

                                // Rule at src/isa/x64/lower.isle line 1718.

15584

                                return Some(v917);

15585

15586

15587

                        match v3 {

15588

                            I128 => {

15589

                                let v305 = C::put_in_regs(ctx, v301);

15590

                                let v306 = constructor_value_regs_get_gpr(ctx, v305, 0x0);

15591

                                let v922 = constructor_do_popcnt(ctx, I64, v306);

15592

                                let v870 = C::put_in_regs(ctx, v301);

15593

                                let v894 = constructor_value_regs_get_gpr(ctx, v870, 0x1);

15594

                                let v923 = constructor_do_popcnt(ctx, I64, v894);

15595

                                let v924 = &C::gpr_to_gpr_mem_imm(ctx, v923);

15596

                                let v925 = constructor_x64_add(ctx, I64, v922, v924);

15597

                                let v926 = C::gpr_to_reg(ctx, v925);

15598

                                let v915 = constructor_imm(ctx, I64, 0x0);

15599

                                let v927 = C::value_regs(ctx, v926, v915);

15600

                                let v928 = C::output(ctx, v927);

15601

                                // Rule at src/isa/x64/lower.isle line 1737.

15602

                                return Some(v928);

15603

15604

                            I8X16 => {

15605

                                let v363 = C::avx512vl_enabled(ctx, v3);

15606

                                if v363 == true {

15607

                                    let v929 = C::avx512bitalg_enabled(ctx, v3);

15608

                                    if v929 == true {

15609

                                        let v459 = &C::put_in_xmm_mem(ctx, v301);

15610

                                        let v930 = constructor_x64_vpopcntb(ctx, v459);

15611

                                        let v931 = constructor_output_xmm(ctx, v930);

15612

                                        // Rule at src/isa/x64/lower.isle line 1810.

15613

                                        return Some(v931);

15614

15615

15616

                                let v932 = C::popcount_4bit_table(ctx);

15617

                                let v933 = C::popcount_low_mask(ctx);

15618

                                let v934 = &constructor_const_to_xmm_mem(ctx, v933);

15619

                                let v935 = constructor_put_in_xmm(ctx, v301);

15620

                                let v936 = constructor_sse_and(ctx, I8X16, v935, v934);

15621

                                let v937 = constructor_put_in_xmm(ctx, v301);

15622

                                let v939 = &C::xmi_imm(ctx, 0x4);

15623

                                let v940 = constructor_x64_psrlw(ctx, v937, v939);

15624

                                let v941 = constructor_sse_and(ctx, I8X16, v940, v934);

15625

                                let v942 = C::popcount_4bit_table(ctx);

15626

                                let v943 = constructor_x64_xmm_load_const(ctx, I8X16, v942);

15627

                                let v944 = &C::xmm_to_xmm_mem(ctx, v936);

15628

                                let v945 = constructor_x64_pshufb(ctx, v943, v944);

15629

                                let v946 = &C::xmm_to_xmm_mem(ctx, v941);

15630

                                let v947 = constructor_x64_pshufb(ctx, v943, v946);

15631

                                let v948 = &C::xmm_to_xmm_mem(ctx, v947);

15632

                                let v949 = constructor_x64_paddb(ctx, v945, v948);

15633

                                let v950 = constructor_output_xmm(ctx, v949);

15634

                                // Rule at src/isa/x64/lower.isle line 1844.

15635

                                return Some(v950);

15636

15637

                            _ => {}

15638

15639

                        let v45 = C::ty_32_or_64(ctx, v3);

15640

                        if let Some(v46) = v45 {

15641

                            let v302 = constructor_put_in_gpr(ctx, v301);

15642

                            let v918 = constructor_do_popcnt(ctx, v46, v302);

15643

                            let v919 = constructor_output_gpr(ctx, v918);

15644

                            // Rule at src/isa/x64/lower.isle line 1727.

15645

                            return Some(v919);

15646

15647

                        let v863 = C::ty_8_or_16(ctx, v3);

15648

                        if let Some(v864) = v863 {

15649

                            let v865 = constructor_extend_to_gpr(ctx, v301, I32, &ExtendKind::Zero);

15650

                            let v920 = constructor_do_popcnt(ctx, I32, v865);

15651

                            let v921 = constructor_output_gpr(ctx, v920);

15652

                            // Rule at src/isa/x64/lower.isle line 1732.

15653

                            return Some(v921);

15654

15655

15656

15657

                &Opcode::Sqrt => {

15658

                    let v1 = C::first_result(ctx, arg0);

15659

                    if let Some(v2) = v1 {

15660

                        let v3 = C::value_type(ctx, v2);

15661

                        match v3 {

15662

                            F32 => {

15663

                                let v459 = &C::put_in_xmm_mem(ctx, v301);

15664

                                let v1065 = constructor_x64_sqrtss(ctx, v459);

15665

                                let v1066 = constructor_output_xmm(ctx, v1065);

15666

                                // Rule at src/isa/x64/lower.isle line 2095.

15667

                                return Some(v1066);

15668

15669

                            F64 => {

15670

                                let v459 = &C::put_in_xmm_mem(ctx, v301);

15671

                                let v1067 = constructor_x64_sqrtsd(ctx, v459);

15672

                                let v1068 = constructor_output_xmm(ctx, v1067);

15673

                                // Rule at src/isa/x64/lower.isle line 2097.

15674

                                return Some(v1068);

15675

15676

                            F32X4 => {

15677

                                let v459 = &C::put_in_xmm_mem(ctx, v301);

15678

                                let v1069 = constructor_x64_sqrtps(ctx, v459);

15679

                                let v1070 = constructor_output_xmm(ctx, v1069);

15680

                                // Rule at src/isa/x64/lower.isle line 2099.

15681

                                return Some(v1070);

15682

15683

                            F64X2 => {

15684

                                let v459 = &C::put_in_xmm_mem(ctx, v301);

15685

                                let v1071 = constructor_x64_sqrtpd(ctx, v459);

15686

                                let v1072 = constructor_output_xmm(ctx, v1071);

15687

                                // Rule at src/isa/x64/lower.isle line 2101.

15688

                                return Some(v1072);

15689

15690

                            _ => {}

15691

15692

15693

15694

                &Opcode::Fneg => {

15695

                    let v1 = C::first_result(ctx, arg0);

15696

                    if let Some(v2) = v1 {

15697

                        let v3 = C::value_type(ctx, v2);

15698

                        match v3 {

15699

                            F32 => {

15700

                                let v469 = constructor_put_in_xmm(ctx, v301);

15701

                                let v508 = constructor_imm(ctx, F32, 0x80000000);

15702

                                let v509 = &constructor_reg_to_xmm_mem(ctx, v508);

15703

                                let v510 = constructor_x64_xorps(ctx, v469, v509);

15704

                                let v511 = constructor_output_xmm(ctx, v510);

15705

                                // Rule at src/isa/x64/lower.isle line 1099.

15706

                                return Some(v511);

15707

15708

                            F64 => {

15709

                                let v469 = constructor_put_in_xmm(ctx, v301);

15710

                                let v513 = constructor_imm(ctx, F64, 0x8000000000000000);

15711

                                let v514 = &constructor_reg_to_xmm_mem(ctx, v513);

15712

                                let v515 = constructor_x64_xorpd(ctx, v469, v514);

15713

                                let v516 = constructor_output_xmm(ctx, v515);

15714

                                // Rule at src/isa/x64/lower.isle line 1102.

15715

                                return Some(v516);

15716

15717

                            F32X4 => {

15718

                                let v469 = constructor_put_in_xmm(ctx, v301);

15719

                                let v496 = constructor_vector_all_ones(ctx);

15720

                                let v518 = &C::xmi_imm(ctx, 0x1F);

15721

                                let v519 = constructor_x64_pslld(ctx, v496, v518);

15722

                                let v520 = &C::xmm_to_xmm_mem(ctx, v519);

15723

                                let v521 = constructor_x64_xorps(ctx, v469, v520);

15724

                                let v522 = constructor_output_xmm(ctx, v521);

15725

                                // Rule at src/isa/x64/lower.isle line 1105.

15726

                                return Some(v522);

15727

15728

                            F64X2 => {

15729

                                let v469 = constructor_put_in_xmm(ctx, v301);

15730

                                let v496 = constructor_vector_all_ones(ctx);

15731

                                let v524 = &C::xmi_imm(ctx, 0x3F);

15732

                                let v525 = constructor_x64_psllq(ctx, v496, v524);

15733

                                let v526 = &C::xmm_to_xmm_mem(ctx, v525);

15734

                                let v527 = constructor_x64_xorpd(ctx, v469, v526);

15735

                                let v528 = constructor_output_xmm(ctx, v527);

15736

                                // Rule at src/isa/x64/lower.isle line 1109.

15737

                                return Some(v528);

15738

15739

                            _ => {}

15740

15741

15742

15743

                &Opcode::Fabs => {

15744

                    let v1 = C::first_result(ctx, arg0);

15745

                    if let Some(v2) = v1 {

15746

                        let v3 = C::value_type(ctx, v2);

15747

                        match v3 {

15748

                            F32 => {

15749

                                let v469 = constructor_put_in_xmm(ctx, v301);

15750

                                let v487 = constructor_imm(ctx, F32, 0x7FFFFFFF);

15751

                                let v488 = &constructor_reg_to_xmm_mem(ctx, v487);

15752

                                let v489 = constructor_x64_andps(ctx, v469, v488);

15753

                                let v490 = constructor_output_xmm(ctx, v489);

15754

                                // Rule at src/isa/x64/lower.isle line 1081.

15755

                                return Some(v490);

15756

15757

                            F64 => {

15758

                                let v469 = constructor_put_in_xmm(ctx, v301);

15759

                                let v492 = constructor_imm(ctx, F64, 0x7FFFFFFFFFFFFFFF);

15760

                                let v493 = &constructor_reg_to_xmm_mem(ctx, v492);

15761

                                let v494 = constructor_x64_andpd(ctx, v469, v493);

15762

                                let v495 = constructor_output_xmm(ctx, v494);

15763

                                // Rule at src/isa/x64/lower.isle line 1084.

15764

                                return Some(v495);

15765

15766

                            F32X4 => {

15767

                                let v469 = constructor_put_in_xmm(ctx, v301);

15768

                                let v496 = constructor_vector_all_ones(ctx);

15769

                                let v498 = &C::xmi_imm(ctx, 0x1);

15770

                                let v499 = constructor_x64_psrld(ctx, v496, v498);

15771

                                let v500 = &C::xmm_to_xmm_mem(ctx, v499);

15772

                                let v501 = constructor_x64_andps(ctx, v469, v500);

15773

                                let v502 = constructor_output_xmm(ctx, v501);

15774

                                // Rule at src/isa/x64/lower.isle line 1088.

15775

                                return Some(v502);

15776

15777

                            F64X2 => {

15778

                                let v469 = constructor_put_in_xmm(ctx, v301);

15779

                                let v496 = constructor_vector_all_ones(ctx);

15780

                                let v498 = &C::xmi_imm(ctx, 0x1);

15781

                                let v503 = constructor_x64_psrlq(ctx, v496, v498);

15782

                                let v504 = &C::xmm_to_xmm_mem(ctx, v503);

15783

                                let v505 = constructor_x64_andpd(ctx, v469, v504);

15784

                                let v506 = constructor_output_xmm(ctx, v505);

15785

                                // Rule at src/isa/x64/lower.isle line 1093.

15786

                                return Some(v506);

15787

15788

                            _ => {}

15789

15790

15791

15792

                &Opcode::Ceil => {

15793

                    let v1 = C::first_result(ctx, arg0);

15794

                    if let Some(v2) = v1 {

15795

                        let v529 = C::value_type(ctx, v301);

15796

                        match v529 {

15797

                            F32 => {

15798

                                let v3 = C::value_type(ctx, v2);

15799

                                let v1814 = C::use_sse41(ctx, v3);

15800

                                match v1814 {

15801

                                    true => {

15802

                                        let v459 = &C::put_in_xmm_mem(ctx, v301);

15803

                                        let v1816 =

15804

                                            constructor_x64_roundss(ctx, v459, &RoundImm::RoundUp);

15805

                                        let v1817 = constructor_output_xmm(ctx, v1816);

15806

                                        // Rule at src/isa/x64/lower.isle line 3289.

15807

                                        return Some(v1817);

15808

15809

                                    false => {

15810

                                        let v1819 = C::put_in_reg(ctx, v301);

15811

                                        let v1820 = C::libcall_1(ctx, &LibCall::CeilF32, v1819);

15812

                                        let v1821 = constructor_output_reg(ctx, v1820);

15813

                                        // Rule at src/isa/x64/lower.isle line 3292.

15814

                                        return Some(v1821);

15815

15816

                                    _ => {}

15817

15818

15819

                            F64 => {

15820

                                let v3 = C::value_type(ctx, v2);

15821

                                let v1814 = C::use_sse41(ctx, v3);

15822

                                match v1814 {

15823

                                    true => {

15824

                                        let v459 = &C::put_in_xmm_mem(ctx, v301);

15825

                                        let v1822 =

15826

                                            constructor_x64_roundsd(ctx, v459, &RoundImm::RoundUp);

15827

                                        let v1823 = constructor_output_xmm(ctx, v1822);

15828

                                        // Rule at src/isa/x64/lower.isle line 3295.

15829

                                        return Some(v1823);

15830

15831

                                    false => {

15832

                                        let v1819 = C::put_in_reg(ctx, v301);

15833

                                        let v1825 = C::libcall_1(ctx, &LibCall::CeilF64, v1819);

15834

                                        let v1826 = constructor_output_reg(ctx, v1825);

15835

                                        // Rule at src/isa/x64/lower.isle line 3298.

15836

                                        return Some(v1826);

15837

15838

                                    _ => {}

15839

15840

15841

                            F32X4 => {

15842

                                let v3 = C::value_type(ctx, v2);

15843

                                let v1814 = C::use_sse41(ctx, v3);

15844

                                if v1814 == true {

15845

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

15846

                                    let v1827 =

15847

                                        constructor_x64_roundps(ctx, v459, &RoundImm::RoundUp);

15848

                                    let v1828 = constructor_output_xmm(ctx, v1827);

15849

                                    // Rule at src/isa/x64/lower.isle line 3301.

15850

                                    return Some(v1828);

15851

15852

15853

                            F64X2 => {

15854

                                let v3 = C::value_type(ctx, v2);

15855

                                let v1814 = C::use_sse41(ctx, v3);

15856

                                if v1814 == true {

15857

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

15858

                                    let v1829 =

15859

                                        constructor_x64_roundpd(ctx, v459, &RoundImm::RoundUp);

15860

                                    let v1830 = constructor_output_xmm(ctx, v1829);

15861

                                    // Rule at src/isa/x64/lower.isle line 3304.

15862

                                    return Some(v1830);

15863

15864

15865

                            _ => {}

15866

15867

15868

15869

                &Opcode::Floor => {

15870

                    let v1 = C::first_result(ctx, arg0);

15871

                    if let Some(v2) = v1 {

15872

                        let v529 = C::value_type(ctx, v301);

15873

                        match v529 {

15874

                            F32 => {

15875

                                let v3 = C::value_type(ctx, v2);

15876

                                let v1814 = C::use_sse41(ctx, v3);

15877

                                match v1814 {

15878

                                    true => {

15879

                                        let v459 = &C::put_in_xmm_mem(ctx, v301);

15880

                                        let v1832 = constructor_x64_roundss(

15881

                                            ctx,

15882

                                            v459,

15883

                                            &RoundImm::RoundDown,

15884

);

15885

                                        let v1833 = constructor_output_xmm(ctx, v1832);

15886

                                        // Rule at src/isa/x64/lower.isle line 3309.

15887

                                        return Some(v1833);

15888

15889

                                    false => {

15890

                                        let v1819 = C::put_in_reg(ctx, v301);

15891

                                        let v1835 = C::libcall_1(ctx, &LibCall::FloorF32, v1819);

15892

                                        let v1836 = constructor_output_reg(ctx, v1835);

15893

                                        // Rule at src/isa/x64/lower.isle line 3312.

15894

                                        return Some(v1836);

15895

15896

                                    _ => {}

15897

15898

15899

                            F64 => {

15900

                                let v3 = C::value_type(ctx, v2);

15901

                                let v1814 = C::use_sse41(ctx, v3);

15902

                                match v1814 {

15903

                                    true => {

15904

                                        let v459 = &C::put_in_xmm_mem(ctx, v301);

15905

                                        let v1837 = constructor_x64_roundsd(

15906

                                            ctx,

15907

                                            v459,

15908

                                            &RoundImm::RoundDown,

15909

);

15910

                                        let v1838 = constructor_output_xmm(ctx, v1837);

15911

                                        // Rule at src/isa/x64/lower.isle line 3315.

15912

                                        return Some(v1838);

15913

15914

                                    false => {

15915

                                        let v1819 = C::put_in_reg(ctx, v301);

15916

                                        let v1840 = C::libcall_1(ctx, &LibCall::FloorF64, v1819);

15917

                                        let v1841 = constructor_output_reg(ctx, v1840);

15918

                                        // Rule at src/isa/x64/lower.isle line 3318.

15919

                                        return Some(v1841);

15920

15921

                                    _ => {}

15922

15923

15924

                            F32X4 => {

15925

                                let v3 = C::value_type(ctx, v2);

15926

                                let v1814 = C::use_sse41(ctx, v3);

15927

                                if v1814 == true {

15928

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

15929

                                    let v1842 =

15930

                                        constructor_x64_roundps(ctx, v459, &RoundImm::RoundDown);

15931

                                    let v1843 = constructor_output_xmm(ctx, v1842);

15932

                                    // Rule at src/isa/x64/lower.isle line 3321.

15933

                                    return Some(v1843);

15934

15935

15936

                            F64X2 => {

15937

                                let v3 = C::value_type(ctx, v2);

15938

                                let v1814 = C::use_sse41(ctx, v3);

15939

                                if v1814 == true {

15940

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

15941

                                    let v1844 =

15942

                                        constructor_x64_roundpd(ctx, v459, &RoundImm::RoundDown);

15943

                                    let v1845 = constructor_output_xmm(ctx, v1844);

15944

                                    // Rule at src/isa/x64/lower.isle line 3324.

15945

                                    return Some(v1845);

15946

15947

15948

                            _ => {}

15949

15950

15951

15952

                &Opcode::Trunc => {

15953

                    let v1 = C::first_result(ctx, arg0);

15954

                    if let Some(v2) = v1 {

15955

                        let v529 = C::value_type(ctx, v301);

15956

                        match v529 {

15957

                            F32 => {

15958

                                let v3 = C::value_type(ctx, v2);

15959

                                let v1814 = C::use_sse41(ctx, v3);

15960

                                match v1814 {

15961

                                    true => {

15962

                                        let v459 = &C::put_in_xmm_mem(ctx, v301);

15963

                                        let v1862 = constructor_x64_roundss(

15964

                                            ctx,

15965

                                            v459,

15966

                                            &RoundImm::RoundZero,

15967

);

15968

                                        let v1863 = constructor_output_xmm(ctx, v1862);

15969

                                        // Rule at src/isa/x64/lower.isle line 3349.

15970

                                        return Some(v1863);

15971

15972

                                    false => {

15973

                                        let v1819 = C::put_in_reg(ctx, v301);

15974

                                        let v1865 = C::libcall_1(ctx, &LibCall::TruncF32, v1819);

15975

                                        let v1866 = constructor_output_reg(ctx, v1865);

15976

                                        // Rule at src/isa/x64/lower.isle line 3352.

15977

                                        return Some(v1866);

15978

15979

                                    _ => {}

15980

15981

15982

                            F64 => {

15983

                                let v3 = C::value_type(ctx, v2);

15984

                                let v1814 = C::use_sse41(ctx, v3);

15985

                                match v1814 {

15986

                                    true => {

15987

                                        let v459 = &C::put_in_xmm_mem(ctx, v301);

15988

                                        let v1867 = constructor_x64_roundsd(

15989

                                            ctx,

15990

                                            v459,

15991

                                            &RoundImm::RoundZero,

15992

);

15993

                                        let v1868 = constructor_output_xmm(ctx, v1867);

15994

                                        // Rule at src/isa/x64/lower.isle line 3355.

15995

                                        return Some(v1868);

15996

15997

                                    false => {

15998

                                        let v1819 = C::put_in_reg(ctx, v301);

15999

                                        let v1870 = C::libcall_1(ctx, &LibCall::TruncF64, v1819);

16000

                                        let v1871 = constructor_output_reg(ctx, v1870);

16001

                                        // Rule at src/isa/x64/lower.isle line 3358.

16002

                                        return Some(v1871);

16003

16004

                                    _ => {}

16005

16006

16007

                            F32X4 => {

16008

                                let v3 = C::value_type(ctx, v2);

16009

                                let v1814 = C::use_sse41(ctx, v3);

16010

                                if v1814 == true {

16011

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

16012

                                    let v1872 =

16013

                                        constructor_x64_roundps(ctx, v459, &RoundImm::RoundZero);

16014

                                    let v1873 = constructor_output_xmm(ctx, v1872);

16015

                                    // Rule at src/isa/x64/lower.isle line 3361.

16016

                                    return Some(v1873);

16017

16018

16019

                            F64X2 => {

16020

                                let v3 = C::value_type(ctx, v2);

16021

                                let v1814 = C::use_sse41(ctx, v3);

16022

                                if v1814 == true {

16023

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

16024

                                    let v1874 =

16025

                                        constructor_x64_roundpd(ctx, v459, &RoundImm::RoundZero);

16026

                                    let v1875 = constructor_output_xmm(ctx, v1874);

16027

                                    // Rule at src/isa/x64/lower.isle line 3364.

16028

                                    return Some(v1875);

16029

16030

16031

                            _ => {}

16032

16033

16034

16035

                &Opcode::Nearest => {

16036

                    let v1 = C::first_result(ctx, arg0);

16037

                    if let Some(v2) = v1 {

16038

                        let v529 = C::value_type(ctx, v301);

16039

                        match v529 {

16040

                            F32 => {

16041

                                let v3 = C::value_type(ctx, v2);

16042

                                let v1814 = C::use_sse41(ctx, v3);

16043

                                match v1814 {

16044

                                    true => {

16045

                                        let v459 = &C::put_in_xmm_mem(ctx, v301);

16046

                                        let v1847 = constructor_x64_roundss(

16047

                                            ctx,

16048

                                            v459,

16049

                                            &RoundImm::RoundNearest,

16050

);

16051

                                        let v1848 = constructor_output_xmm(ctx, v1847);

16052

                                        // Rule at src/isa/x64/lower.isle line 3329.

16053

                                        return Some(v1848);

16054

16055

                                    false => {

16056

                                        let v1819 = C::put_in_reg(ctx, v301);

16057

                                        let v1850 = C::libcall_1(ctx, &LibCall::NearestF32, v1819);

16058

                                        let v1851 = constructor_output_reg(ctx, v1850);

16059

                                        // Rule at src/isa/x64/lower.isle line 3332.

16060

                                        return Some(v1851);

16061

16062

                                    _ => {}

16063

16064

16065

                            F64 => {

16066

                                let v3 = C::value_type(ctx, v2);

16067

                                let v1814 = C::use_sse41(ctx, v3);

16068

                                match v1814 {

16069

                                    true => {

16070

                                        let v459 = &C::put_in_xmm_mem(ctx, v301);

16071

                                        let v1852 = constructor_x64_roundsd(

16072

                                            ctx,

16073

                                            v459,

16074

                                            &RoundImm::RoundNearest,

16075

);

16076

                                        let v1853 = constructor_output_xmm(ctx, v1852);

16077

                                        // Rule at src/isa/x64/lower.isle line 3335.

16078

                                        return Some(v1853);

16079

16080

                                    false => {

16081

                                        let v1819 = C::put_in_reg(ctx, v301);

16082

                                        let v1855 = C::libcall_1(ctx, &LibCall::NearestF64, v1819);

16083

                                        let v1856 = constructor_output_reg(ctx, v1855);

16084

                                        // Rule at src/isa/x64/lower.isle line 3338.

16085

                                        return Some(v1856);

16086

16087

                                    _ => {}

16088

16089

16090

                            F32X4 => {

16091

                                let v3 = C::value_type(ctx, v2);

16092

                                let v1814 = C::use_sse41(ctx, v3);

16093

                                if v1814 == true {

16094

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

16095

                                    let v1857 =

16096

                                        constructor_x64_roundps(ctx, v459, &RoundImm::RoundNearest);

16097

                                    let v1858 = constructor_output_xmm(ctx, v1857);

16098

                                    // Rule at src/isa/x64/lower.isle line 3341.

16099

                                    return Some(v1858);

16100

16101

16102

                            F64X2 => {

16103

                                let v3 = C::value_type(ctx, v2);

16104

                                let v1814 = C::use_sse41(ctx, v3);

16105

                                if v1814 == true {

16106

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

16107

                                    let v1859 =

16108

                                        constructor_x64_roundpd(ctx, v459, &RoundImm::RoundNearest);

16109

                                    let v1860 = constructor_output_xmm(ctx, v1859);

16110

                                    // Rule at src/isa/x64/lower.isle line 3344.

16111

                                    return Some(v1860);

16112

16113

16114

                            _ => {}

16115

16116

16117

16118

                &Opcode::IsNull => {

16119

                    let v529 = C::value_type(ctx, v301);

16120

                    if v529 == R64 {

16121

                        let v302 = constructor_put_in_gpr(ctx, v301);

16122

                        let v983 = &constructor_x64_cmp_imm(ctx, &OperandSize::Size64, 0x0, v302);

16123

                        let v984 = &constructor_x64_setcc(ctx, &CC::Z);

16124

                        let v985 = constructor_with_flags(ctx, v983, v984);

16125

                        let v986 = C::output(ctx, v985);

16126

                        // Rule at src/isa/x64/lower.isle line 1957.

16127

                        return Some(v986);

16128

16129

16130

                &Opcode::IsInvalid => {

16131

                    let v529 = C::value_type(ctx, v301);

16132

                    if v529 == R64 {

16133

                        let v302 = constructor_put_in_gpr(ctx, v301);

16134

                        let v988 =

16135

                            &constructor_x64_cmp_imm(ctx, &OperandSize::Size64, 0xFFFFFFFF, v302);

16136

                        let v984 = &constructor_x64_setcc(ctx, &CC::Z);

16137

                        let v989 = constructor_with_flags(ctx, v988, v984);

16138

                        let v990 = C::output(ctx, v989);

16139

                        // Rule at src/isa/x64/lower.isle line 1965.

16140

                        return Some(v990);

16141

16142

16143

                &Opcode::ScalarToVector => {

16144

                    let v2109 = &C::sinkable_load(ctx, v301);

16145

                    if let Some(v2110) = v2109 {

16146

                        let v529 = C::value_type(ctx, v301);

16147

                        let v2116 = C::ty_64(ctx, v529);

16148

                        if let Some(v2117) = v2116 {

16149

                            let v2113 = &C::sink_load(ctx, v2110);

16150

                            let v2118 = constructor_x64_movsd_load(ctx, v2113);

16151

                            let v2119 = constructor_output_xmm(ctx, v2118);

16152

                            // Rule at src/isa/x64/lower.isle line 3768.

16153

                            return Some(v2119);

16154

16155

                        let v2111 = C::ty_32(ctx, v529);

16156

                        if let Some(v2112) = v2111 {

16157

                            let v2113 = &C::sink_load(ctx, v2110);

16158

                            let v2114 = constructor_x64_movss_load(ctx, v2113);

16159

                            let v2115 = constructor_output_xmm(ctx, v2114);

16160

                            // Rule at src/isa/x64/lower.isle line 3766.

16161

                            return Some(v2115);

16162

16163

16164

                    let v529 = C::value_type(ctx, v301);

16165

                    let v1616 = C::ty_scalar_float(ctx, v529);

16166

                    if let Some(v1617) = v1616 {

16167

                        let v1009 = constructor_output_value(ctx, v301);

16168

                        // Rule at src/isa/x64/lower.isle line 3756.

16169

                        return Some(v1009);

16170

16171

                    let v302 = constructor_put_in_gpr(ctx, v301);

16172

                    let v2107 = constructor_bitcast_gpr_to_xmm(ctx, v529, v302);

16173

                    let v2108 = constructor_output_xmm(ctx, v2107);

16174

                    // Rule at src/isa/x64/lower.isle line 3761.

16175

                    return Some(v2108);

16176

16177

                &Opcode::Bmask => {

16178

                    let v1 = C::first_result(ctx, arg0);

16179

                    if let Some(v2) = v1 {

16180

                        let v305 = C::put_in_regs(ctx, v301);

16181

                        let v3 = C::value_type(ctx, v2);

16182

                        let v529 = C::value_type(ctx, v301);

16183

                        let v530 = constructor_lower_bmask(ctx, v3, v529, v305);

16184

                        let v531 = C::output(ctx, v530);

16185

                        // Rule at src/isa/x64/lower.isle line 1154.

16186

                        return Some(v531);

16187

16188

16189

                &Opcode::Ireduce => {

16190

                    let v1 = C::first_result(ctx, arg0);

16191

                    if let Some(v2) = v1 {

16192

                        let v3 = C::value_type(ctx, v2);

16193

                        let v4 = C::fits_in_64(ctx, v3);

16194

                        if let Some(v5) = v4 {

16195

                            let v305 = C::put_in_regs(ctx, v301);

16196

                            let v306 = constructor_value_regs_get_gpr(ctx, v305, 0x0);

16197

                            let v1010 = constructor_output_gpr(ctx, v306);

16198

                            // Rule at src/isa/x64/lower.isle line 2015.

16199

                            return Some(v1010);

16200

16201

                        let v529 = C::value_type(ctx, v301);

16202

                        if v3 == v529 {

16203

                            let v1009 = constructor_output_value(ctx, v301);

16204

                            // Rule at src/isa/x64/lower.isle line 2009.

16205

                            return Some(v1009);

16206

16207

16208

16209

                &Opcode::SwidenLow => {

16210

                    let v1 = C::first_result(ctx, arg0);

16211

                    if let Some(v2) = v1 {

16212

                        let v3 = C::value_type(ctx, v2);

16213

                        match v3 {

16214

                            I16X8 => {

16215

                                let v529 = C::value_type(ctx, v301);

16216

                                if v529 == I8X16 {

16217

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

16218

                                    let v1728 = constructor_x64_pmovsxbw(ctx, v459);

16219

                                    let v1729 = constructor_output_xmm(ctx, v1728);

16220

                                    // Rule at src/isa/x64/lower.isle line 3154.

16221

                                    return Some(v1729);

16222

16223

16224

                            I32X4 => {

16225

                                let v529 = C::value_type(ctx, v301);

16226

                                if v529 == I16X8 {

16227

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

16228

                                    let v1730 = constructor_x64_pmovsxwd(ctx, v459);

16229

                                    let v1731 = constructor_output_xmm(ctx, v1730);

16230

                                    // Rule at src/isa/x64/lower.isle line 3157.

16231

                                    return Some(v1731);

16232

16233

16234

                            I64X2 => {

16235

                                let v529 = C::value_type(ctx, v301);

16236

                                if v529 == I32X4 {

16237

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

16238

                                    let v1732 = constructor_x64_pmovsxdq(ctx, v459);

16239

                                    let v1733 = constructor_output_xmm(ctx, v1732);

16240

                                    // Rule at src/isa/x64/lower.isle line 3160.

16241

                                    return Some(v1733);

16242

16243

16244

                            _ => {}

16245

16246

16247

16248

                &Opcode::SwidenHigh => {

16249

                    let v1 = C::first_result(ctx, arg0);

16250

                    if let Some(v2) = v1 {

16251

                        let v3 = C::value_type(ctx, v2);

16252

                        match v3 {

16253

                            I16X8 => {

16254

                                let v529 = C::value_type(ctx, v301);

16255

                                if v529 == I8X16 {

16256

                                    let v469 = constructor_put_in_xmm(ctx, v301);

16257

                                    let v1075 = &C::xmm_to_xmm_mem(ctx, v469);

16258

                                    let v1734 = constructor_x64_palignr(ctx, v469, v1075, 0x8);

16259

                                    let v1735 = &C::xmm_to_xmm_mem(ctx, v1734);

16260

                                    let v1736 = constructor_x64_pmovsxbw(ctx, v1735);

16261

                                    let v1737 = constructor_output_xmm(ctx, v1736);

16262

                                    // Rule at src/isa/x64/lower.isle line 3165.

16263

                                    return Some(v1737);

16264

16265

16266

                            I32X4 => {

16267

                                let v529 = C::value_type(ctx, v301);

16268

                                if v529 == I16X8 {

16269

                                    let v469 = constructor_put_in_xmm(ctx, v301);

16270

                                    let v1075 = &C::xmm_to_xmm_mem(ctx, v469);

16271

                                    let v1734 = constructor_x64_palignr(ctx, v469, v1075, 0x8);

16272

                                    let v1735 = &C::xmm_to_xmm_mem(ctx, v1734);

16273

                                    let v1738 = constructor_x64_pmovsxwd(ctx, v1735);

16274

                                    let v1739 = constructor_output_xmm(ctx, v1738);

16275

                                    // Rule at src/isa/x64/lower.isle line 3169.

16276

                                    return Some(v1739);

16277

16278

16279

                            I64X2 => {

16280

                                let v529 = C::value_type(ctx, v301);

16281

                                if v529 == I32X4 {

16282

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

16283

                                    let v1740 = constructor_x64_pshufd(ctx, v459, 0xEE);

16284

                                    let v1741 = &C::xmm_to_xmm_mem(ctx, v1740);

16285

                                    let v1742 = constructor_x64_pmovsxdq(ctx, v1741);

16286

                                    let v1743 = constructor_output_xmm(ctx, v1742);

16287

                                    // Rule at src/isa/x64/lower.isle line 3173.

16288

                                    return Some(v1743);

16289

16290

16291

                            _ => {}

16292

16293

16294

16295

                &Opcode::UwidenLow => {

16296

                    let v1 = C::first_result(ctx, arg0);

16297

                    if let Some(v2) = v1 {

16298

                        let v3 = C::value_type(ctx, v2);

16299

                        match v3 {

16300

                            I16X8 => {

16301

                                let v529 = C::value_type(ctx, v301);

16302

                                if v529 == I8X16 {

16303

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

16304

                                    let v1744 = constructor_x64_pmovzxbw(ctx, v459);

16305

                                    let v1745 = constructor_output_xmm(ctx, v1744);

16306

                                    // Rule at src/isa/x64/lower.isle line 3178.

16307

                                    return Some(v1745);

16308

16309

16310

                            I32X4 => {

16311

                                let v529 = C::value_type(ctx, v301);

16312

                                if v529 == I16X8 {

16313

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

16314

                                    let v1746 = constructor_x64_pmovzxwd(ctx, v459);

16315

                                    let v1747 = constructor_output_xmm(ctx, v1746);

16316

                                    // Rule at src/isa/x64/lower.isle line 3181.

16317

                                    return Some(v1747);

16318

16319

16320

                            I64X2 => {

16321

                                let v529 = C::value_type(ctx, v301);

16322

                                if v529 == I32X4 {

16323

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

16324

                                    let v1748 = constructor_x64_pmovzxdq(ctx, v459);

16325

                                    let v1749 = constructor_output_xmm(ctx, v1748);

16326

                                    // Rule at src/isa/x64/lower.isle line 3184.

16327

                                    return Some(v1749);

16328

16329

16330

                            _ => {}

16331

16332

16333

16334

                &Opcode::UwidenHigh => {

16335

                    let v1 = C::first_result(ctx, arg0);

16336

                    if let Some(v2) = v1 {

16337

                        let v3 = C::value_type(ctx, v2);

16338

                        match v3 {

16339

                            I16X8 => {

16340

                                let v529 = C::value_type(ctx, v301);

16341

                                if v529 == I8X16 {

16342

                                    let v469 = constructor_put_in_xmm(ctx, v301);

16343

                                    let v1075 = &C::xmm_to_xmm_mem(ctx, v469);

16344

                                    let v1734 = constructor_x64_palignr(ctx, v469, v1075, 0x8);

16345

                                    let v1735 = &C::xmm_to_xmm_mem(ctx, v1734);

16346

                                    let v1750 = constructor_x64_pmovzxbw(ctx, v1735);

16347

                                    let v1751 = constructor_output_xmm(ctx, v1750);

16348

                                    // Rule at src/isa/x64/lower.isle line 3189.

16349

                                    return Some(v1751);

16350

16351

16352

                            I32X4 => {

16353

                                let v529 = C::value_type(ctx, v301);

16354

                                if v529 == I16X8 {

16355

                                    let v469 = constructor_put_in_xmm(ctx, v301);

16356

                                    let v1075 = &C::xmm_to_xmm_mem(ctx, v469);

16357

                                    let v1734 = constructor_x64_palignr(ctx, v469, v1075, 0x8);

16358

                                    let v1735 = &C::xmm_to_xmm_mem(ctx, v1734);

16359

                                    let v1752 = constructor_x64_pmovzxwd(ctx, v1735);

16360

                                    let v1753 = constructor_output_xmm(ctx, v1752);

16361

                                    // Rule at src/isa/x64/lower.isle line 3193.

16362

                                    return Some(v1753);

16363

16364

16365

                            I64X2 => {

16366

                                let v529 = C::value_type(ctx, v301);

16367

                                if v529 == I32X4 {

16368

                                    let v459 = &C::put_in_xmm_mem(ctx, v301);

16369

                                    let v1740 = constructor_x64_pshufd(ctx, v459, 0xEE);

16370

                                    let v1741 = &C::xmm_to_xmm_mem(ctx, v1740);

16371

                                    let v1754 = constructor_x64_pmovzxdq(ctx, v1741);

16372

                                    let v1755 = constructor_output_xmm(ctx, v1754);

16373

                                    // Rule at src/isa/x64/lower.isle line 3197.

16374

                                    return Some(v1755);

16375

16376

16377

                            _ => {}

16378

16379

16380

16381

                &Opcode::Uextend => {

16382

                    let v1 = C::first_result(ctx, arg0);

16383

                    if let Some(v2) = v1 {

16384

                        let v3 = C::value_type(ctx, v2);

16385

                        match v3 {

16386

                            I64 => {

16387

                                let v991 =

16388

                                    constructor_extend_to_gpr(ctx, v301, I64, &ExtendKind::Zero);

16389

                                let v996 = constructor_output_gpr(ctx, v991);

16390

                                // Rule at src/isa/x64/lower.isle line 1978.

16391

                                return Some(v996);

16392

16393

                            I128 => {

16394

                                let v991 =

16395

                                    constructor_extend_to_gpr(ctx, v301, I64, &ExtendKind::Zero);

16396

                                let v992 = C::gpr_to_reg(ctx, v991);

16397

                                let v993 = constructor_imm(ctx, I64, 0x0);

16398

                                let v994 = C::value_regs(ctx, v992, v993);

16399

                                let v995 = C::output(ctx, v994);

16400

                                // Rule at src/isa/x64/lower.isle line 1974.

16401

                                return Some(v995);

16402

16403

                            _ => {}

16404

16405

                        let v997 = C::fits_in_32(ctx, v3);

16406

                        if let Some(v998) = v997 {

16407

                            let v865 = constructor_extend_to_gpr(ctx, v301, I32, &ExtendKind::Zero);

16408

                            let v999 = constructor_output_gpr(ctx, v865);

16409

                            // Rule at src/isa/x64/lower.isle line 1983.

16410

                            return Some(v999);

16411

16412

16413

16414

                &Opcode::Sextend => {

16415

                    let v1 = C::first_result(ctx, arg0);

16416

                    if let Some(v2) = v1 {

16417

                        let v3 = C::value_type(ctx, v2);

16418

                        match v3 {

16419

                            I64 => {

16420

                                let v1000 =

16421

                                    constructor_extend_to_gpr(ctx, v301, I64, &ExtendKind::Sign);

16422

                                let v1006 = constructor_output_gpr(ctx, v1000);

16423

                                // Rule at src/isa/x64/lower.isle line 1998.

16424

                                return Some(v1006);

16425

16426

                            I128 => {

16427

                                let v1000 =

16428

                                    constructor_extend_to_gpr(ctx, v301, I64, &ExtendKind::Sign);

16429

                                let v673 = Imm8Reg::Imm8 { imm: 0x3F };

16430

                                let v674 = &C::imm8_reg_to_imm8_gpr(ctx, &v673);

16431

                                let v1001 = constructor_x64_sar(ctx, I64, v1000, v674);

16432

                                let v1002 = C::gpr_to_reg(ctx, v1000);

16433

                                let v1003 = C::gpr_to_reg(ctx, v1001);

16434

                                let v1004 = C::value_regs(ctx, v1002, v1003);

16435

                                let v1005 = C::output(ctx, v1004);

16436

                                // Rule at src/isa/x64/lower.isle line 1992.

16437

                                return Some(v1005);

16438

16439

                            _ => {}

16440

16441

                        let v997 = C::fits_in_32(ctx, v3);

16442

                        if let Some(v998) = v997 {

16443

                            let v1007 =

16444

                                constructor_extend_to_gpr(ctx, v301, I32, &ExtendKind::Sign);

16445

                            let v1008 = constructor_output_gpr(ctx, v1007);

16446

                            // Rule at src/isa/x64/lower.isle line 2003.

16447

                            return Some(v1008);

16448

16449

16450

16451

                &Opcode::Fpromote => {

16452

                    let v1 = C::first_result(ctx, arg0);

16453

                    if let Some(v2) = v1 {

16454

                        let v3 = C::value_type(ctx, v2);

16455

                        if v3 == F64 {

16456

                            let v459 = &C::put_in_xmm_mem(ctx, v301);

16457

                            let v1073 = constructor_x64_cvtss2sd(ctx, v459);

16458

                            let v1074 = constructor_output_xmm(ctx, v1073);

16459

                            // Rule at src/isa/x64/lower.isle line 2105.

16460

                            return Some(v1074);

16461

16462

16463

16464

                &Opcode::Fdemote => {

16465

                    let v1 = C::first_result(ctx, arg0);

16466

                    if let Some(v2) = v1 {

16467

                        let v3 = C::value_type(ctx, v2);

16468

                        if v3 == F32 {

16469

                            let v459 = &C::put_in_xmm_mem(ctx, v301);

16470

                            let v1078 = constructor_x64_cvtsd2ss(ctx, v459);

16471

                            let v1079 = constructor_output_xmm(ctx, v1078);

16472

                            // Rule at src/isa/x64/lower.isle line 2113.

16473

                            return Some(v1079);

16474

16475

16476

16477

                &Opcode::Fvdemote => {

16478

                    let v1 = C::first_result(ctx, arg0);

16479

                    if let Some(v2) = v1 {

16480

                        let v3 = C::value_type(ctx, v2);

16481

                        if v3 == F32X4 {

16482

                            let v459 = &C::put_in_xmm_mem(ctx, v301);

16483

                            let v1080 = constructor_x64_cvtpd2ps(ctx, v459);

16484

                            let v1081 = constructor_output_xmm(ctx, v1080);

16485

                            // Rule at src/isa/x64/lower.isle line 2117.

16486

                            return Some(v1081);

16487

16488

16489

16490

                &Opcode::FvpromoteLow => {

16491

                    let v1 = C::first_result(ctx, arg0);

16492

                    if let Some(v2) = v1 {

16493

                        let v3 = C::value_type(ctx, v2);

16494

                        if v3 == F64X2 {

16495

                            let v469 = constructor_put_in_xmm(ctx, v301);

16496

                            let v1075 = &C::xmm_to_xmm_mem(ctx, v469);

16497

                            let v1076 = constructor_x64_cvtps2pd(ctx, v1075);

16498

                            let v1077 = constructor_output_xmm(ctx, v1076);

16499

                            // Rule at src/isa/x64/lower.isle line 2109.

16500

                            return Some(v1077);

16501

16502

16503

16504

                &Opcode::FcvtToUint => {

16505

                    let v1 = C::first_result(ctx, arg0);

16506

                    if let Some(v2) = v1 {

16507

                        let v529 = C::value_type(ctx, v301);

16508

                        let v1616 = C::ty_scalar_float(ctx, v529);

16509

                        if let Some(v1617) = v1616 {

16510

                            let v3 = C::value_type(ctx, v2);

16511

                            let v1618 = constructor_cvt_float_to_uint_seq(ctx, v3, v301, false);

16512

                            let v1619 = constructor_output_gpr(ctx, v1618);

16513

                            // Rule at src/isa/x64/lower.isle line 2965.

16514

                            return Some(v1619);

16515

16516

16517

16518

                &Opcode::FcvtToSint => {

16519

                    let v1 = C::first_result(ctx, arg0);

16520

                    if let Some(v2) = v1 {

16521

                        let v529 = C::value_type(ctx, v301);

16522

                        let v1616 = C::ty_scalar_float(ctx, v529);

16523

                        if let Some(v1617) = v1616 {

16524

                            let v3 = C::value_type(ctx, v2);

16525

                            let v1622 = constructor_cvt_float_to_sint_seq(ctx, v3, v301, false);

16526

                            let v1623 = constructor_output_gpr(ctx, v1622);

16527

                            // Rule at src/isa/x64/lower.isle line 2971.

16528

                            return Some(v1623);

16529

16530

16531

16532

                &Opcode::FcvtToUintSat => {

16533

                    let v1 = C::first_result(ctx, arg0);

16534

                    if let Some(v2) = v1 {

16535

                        let v3 = C::value_type(ctx, v2);

16536

                        if v3 == I32X4 {

16537

                            let v529 = C::value_type(ctx, v301);

16538

                            if v529 == F32X4 {

16539

                                let v469 = constructor_put_in_xmm(ctx, v301);

16540

                                let v1640 = constructor_xmm_zero(ctx, F32X4);

16541

                                let v1641 = &C::xmm_to_xmm_mem(ctx, v1640);

16542

                                let v1642 = constructor_x64_maxps(ctx, v469, v1641);

16543

                                let v1643 = &C::xmm_to_xmm_mem(ctx, v1640);

16544

                                let v1644 = constructor_x64_pcmpeqd(ctx, v1640, v1643);

16545

                                let v1645 = &C::xmi_imm(ctx, 0x1);

16546

                                let v1646 = constructor_x64_psrld(ctx, v1644, v1645);

16547

                                let v1647 = &C::xmm_to_xmm_mem(ctx, v1646);

16548

                                let v1648 = constructor_x64_cvtdq2ps(ctx, v1647);

16549

                                let v1649 = &C::xmm_to_xmm_mem(ctx, v1642);

16550

                                let v1650 = constructor_x64_cvttps2dq(ctx, v1649);

16551

                                let v1651 = &C::xmm_to_xmm_mem(ctx, v1648);

16552

                                let v1652 = constructor_x64_subps(ctx, v1642, v1651);

16553

                                let v1653 = &C::xmm_to_xmm_mem(ctx, v1652);

16554

                                let v1654 = constructor_x64_cmpps(

16555

                                    ctx,

16556

                                    v1648,

16557

                                    v1653,

16558

                                    &FcmpImm::LessThanOrEqual,

16559

);

16560

                                let v1655 = &C::xmm_to_xmm_mem(ctx, v1652);

16561

                                let v1656 = constructor_x64_cvttps2dq(ctx, v1655);

16562

                                let v1657 = &C::xmm_to_xmm_mem(ctx, v1654);

16563

                                let v1658 = constructor_x64_pxor(ctx, v1656, v1657);

16564

                                let v1659 = constructor_xmm_zero(ctx, I32X4);

16565

                                let v1660 = &C::xmm_to_xmm_mem(ctx, v1659);

16566

                                let v1661 = constructor_x64_pmaxsd(ctx, v1658, v1660);

16567

                                let v1662 = &C::xmm_to_xmm_mem(ctx, v1650);

16568

                                let v1663 = constructor_x64_paddd(ctx, v1661, v1662);

16569

                                let v1664 = constructor_output_xmm(ctx, v1663);

16570

                                // Rule at src/isa/x64/lower.isle line 3049.

16571

                                return Some(v1664);

16572

16573

16574

                        let v529 = C::value_type(ctx, v301);

16575

                        let v1616 = C::ty_scalar_float(ctx, v529);

16576

                        if let Some(v1617) = v1616 {

16577

                            let v1620 = constructor_cvt_float_to_uint_seq(ctx, v3, v301, true);

16578

                            let v1621 = constructor_output_gpr(ctx, v1620);

16579

                            // Rule at src/isa/x64/lower.isle line 2968.

16580

                            return Some(v1621);

16581

16582

16583

16584

                &Opcode::FcvtToSintSat => {

16585

                    let v1 = C::first_result(ctx, arg0);

16586

                    if let Some(v2) = v1 {

16587

                        let v3 = C::value_type(ctx, v2);

16588

                        if v3 == I32X4 {

16589

                            let v529 = C::value_type(ctx, v301);

16590

                            if v529 == F32X4 {

16591

                                let v469 = constructor_put_in_xmm(ctx, v301);

16592

                                let v1075 = &C::xmm_to_xmm_mem(ctx, v469);

16593

                                let v1626 =

16594

                                    constructor_x64_cmpps(ctx, v469, v1075, &FcmpImm::Equal);

16595

                                let v1627 = &C::xmm_to_xmm_mem(ctx, v1626);

16596

                                let v1628 = constructor_x64_andps(ctx, v469, v1627);

16597

                                let v1629 = &C::xmm_to_xmm_mem(ctx, v1628);

16598

                                let v1630 = constructor_x64_pxor(ctx, v1626, v1629);

16599

                                let v1631 = &C::xmm_to_xmm_mem(ctx, v1628);

16600

                                let v1632 = constructor_x64_cvttps2dq(ctx, v1631);

16601

                                let v1633 = &C::xmm_to_xmm_mem(ctx, v1630);

16602

                                let v1634 = constructor_x64_pand(ctx, v1632, v1633);

16603

                                let v1635 = &C::xmi_imm(ctx, 0x1F);

16604

                                let v1636 = constructor_x64_psrad(ctx, v1634, v1635);

16605

                                let v1637 = &C::xmm_to_xmm_mem(ctx, v1632);

16606

                                let v1638 = constructor_x64_pxor(ctx, v1636, v1637);

16607

                                let v1639 = constructor_output_xmm(ctx, v1638);

16608

                                // Rule at src/isa/x64/lower.isle line 2978.

16609

                                return Some(v1639);

16610

16611

16612

                        let v529 = C::value_type(ctx, v301);

16613

                        let v1616 = C::ty_scalar_float(ctx, v529);

16614

                        if let Some(v1617) = v1616 {

16615

                            let v1624 = constructor_cvt_float_to_sint_seq(ctx, v3, v301, true);

16616

                            let v1625 = constructor_output_gpr(ctx, v1624);

16617

                            // Rule at src/isa/x64/lower.isle line 2974.

16618

                            return Some(v1625);

16619

16620

16621

16622

                &Opcode::X86Cvtt2dq => {

16623

                    let v1 = C::first_result(ctx, arg0);

16624

                    if let Some(v2) = v1 {

16625

                        let v3 = C::value_type(ctx, v2);

16626

                        if v3 == I32X4 {

16627

                            let v529 = C::value_type(ctx, v301);

16628

                            if v529 == F32X4 {

16629

                                let v459 = &C::put_in_xmm_mem(ctx, v301);

16630

                                let v1665 = constructor_x64_cvttps2dq(ctx, v459);

16631

                                let v1666 = constructor_output_xmm(ctx, v1665);

16632

                                // Rule at src/isa/x64/lower.isle line 3096.

16633

                                return Some(v1666);

16634

16635

16636

16637

16638

                &Opcode::FcvtFromUint => {

16639

                    let v1 = C::first_result(ctx, arg0);

16640

                    if let Some(v2) = v1 {

16641

                        let v3 = C::value_type(ctx, v2);

16642

                        match v3 {

16643

                            F32 => {

16644

                                let v529 = C::value_type(ctx, v301);

16645

                                let v1571 = C::fits_in_32(ctx, v529);

16646

                                if let Some(v1572) = v1571 {

16647

                                    let v1573 = C::ty_int(ctx, v1572);

16648

                                    if let Some(v1574) = v1573 {

16649

                                        let v991 = constructor_extend_to_gpr(

16650

                                            ctx,

16651

                                            v301,

16652

                                            I64,

16653

                                            &ExtendKind::Zero,

16654

);

16655

                                        let v1575 = &C::gpr_to_gpr_mem(ctx, v991);

16656

                                        let v1576 = constructor_x64_cvtsi2ss(ctx, I64, v1575);

16657

                                        let v1577 = constructor_output_xmm(ctx, v1576);

16658

                                        // Rule at src/isa/x64/lower.isle line 2893.

16659

                                        return Some(v1577);

16660

16661

16662

16663

                            F64 => {

16664

                                let v529 = C::value_type(ctx, v301);

16665

                                let v1571 = C::fits_in_32(ctx, v529);

16666

                                if let Some(v1572) = v1571 {

16667

                                    let v1573 = C::ty_int(ctx, v1572);

16668

                                    if let Some(v1574) = v1573 {

16669

                                        let v991 = constructor_extend_to_gpr(

16670

                                            ctx,

16671

                                            v301,

16672

                                            I64,

16673

                                            &ExtendKind::Zero,

16674

);

16675

                                        let v1575 = &C::gpr_to_gpr_mem(ctx, v991);

16676

                                        let v1578 = constructor_x64_cvtsi2sd(ctx, I64, v1575);

16677

                                        let v1579 = constructor_output_xmm(ctx, v1578);

16678

                                        // Rule at src/isa/x64/lower.isle line 2896.

16679

                                        return Some(v1579);

16680

16681

16682

16683

                            F32X4 => {

16684

                                let v363 = C::avx512vl_enabled(ctx, v3);

16685

                                if v363 == true {

16686

                                    let v466 = C::avx512f_enabled(ctx, v3);

16687

                                    if v466 == true {

16688

                                        let v459 = &C::put_in_xmm_mem(ctx, v301);

16689

                                        let v1596 = constructor_x64_vcvtudq2ps(ctx, v459);

16690

                                        let v1597 = constructor_output_xmm(ctx, v1596);

16691

                                        // Rule at src/isa/x64/lower.isle line 2914.

16692

                                        return Some(v1597);

16693

16694

16695

                                let v469 = constructor_put_in_xmm(ctx, v301);

16696

                                let v1599 = &C::xmi_imm(ctx, 0x10);

16697

                                let v1600 = constructor_x64_pslld(ctx, v469, v1599);

16698

                                let v1601 = &C::xmi_imm(ctx, 0x10);

16699

                                let v1602 = constructor_x64_psrld(ctx, v1600, v1601);

16700

                                let v1603 = &C::xmm_to_xmm_mem(ctx, v1602);

16701

                                let v1604 = constructor_x64_psubd(ctx, v469, v1603);

16702

                                let v1605 = &C::xmm_to_xmm_mem(ctx, v1602);

16703

                                let v1606 = constructor_x64_cvtdq2ps(ctx, v1605);

16704

                                let v1607 = &C::xmi_imm(ctx, 0x1);

16705

                                let v1608 = constructor_x64_psrld(ctx, v1604, v1607);

16706

                                let v1609 = &C::xmm_to_xmm_mem(ctx, v1608);

16707

                                let v1610 = constructor_x64_cvtdq2ps(ctx, v1609);

16708

                                let v1611 = &C::xmm_to_xmm_mem(ctx, v1610);

16709

                                let v1612 = constructor_x64_addps(ctx, v1610, v1611);

16710

                                let v1613 = &C::xmm_to_xmm_mem(ctx, v1606);

16711

                                let v1614 = constructor_x64_addps(ctx, v1612, v1613);

16712

                                let v1615 = constructor_output_xmm(ctx, v1614);

16713

                                // Rule at src/isa/x64/lower.isle line 2941.

16714

                                return Some(v1615);

16715

16716

                            F64X2 => {

16717

                                let v1582 = C::def_inst(ctx, v301);

16718

                                if let Some(v1583) = v1582 {

16719

                                    let v1584 = &C::inst_data(ctx, v1583);

16720

                                    if let &InstructionData::Unary {

16721

                                        opcode: ref v1585,

16722

                                        arg: v1586,

16723

                                    } = v1584

16724

16725

                                        if let &Opcode::UwidenLow = v1585 {

16726

                                            let v1587 = C::value_type(ctx, v1586);

16727

                                            if v1587 == I32X4 {

16728

                                                let v1588 = C::fcvt_uint_mask_const(ctx);

16729

                                                let v1589 =

16730

                                                    &constructor_const_to_xmm_mem(ctx, v1588);

16731

                                                let v1590 = constructor_put_in_xmm(ctx, v1586);

16732

                                                let v1591 =

16733

                                                    constructor_x64_unpcklps(ctx, v1590, v1589);

16734

                                                let v1592 = C::fcvt_uint_mask_high_const(ctx);

16735

                                                let v1593 =

16736

                                                    &constructor_const_to_xmm_mem(ctx, v1592);

16737

                                                let v1594 =

16738

                                                    constructor_x64_subpd(ctx, v1591, v1593);

16739

                                                let v1595 = constructor_output_xmm(ctx, v1594);

16740

                                                // Rule at src/isa/x64/lower.isle line 2906.

16741

                                                return Some(v1595);

16742

16743

16744

16745

16746

16747

                            _ => {}

16748

16749

                        let v529 = C::value_type(ctx, v301);

16750

                        if v529 == I64 {

16751

                            let v302 = constructor_put_in_gpr(ctx, v301);

16752

                            let v1580 = constructor_cvt_u64_to_float_seq(ctx, v3, v302);

16753

                            let v1581 = constructor_output_xmm(ctx, v1580);

16754

                            // Rule at src/isa/x64/lower.isle line 2899.

16755

                            return Some(v1581);

16756

16757

16758

16759

                &Opcode::FcvtFromSint => {

16760

                    let v1 = C::first_result(ctx, arg0);

16761

                    if let Some(v2) = v1 {

16762

                        let v3 = C::value_type(ctx, v2);

16763

                        match v3 {

16764

                            F32 => {

16765

                                let v529 = C::value_type(ctx, v301);

16766

                                match v529 {

16767

                                    I8 => {

16768

                                        let v1007 = constructor_extend_to_gpr(

16769

                                            ctx,

16770

                                            v301,

16771

                                            I32,

16772

                                            &ExtendKind::Sign,

16773

);

16774

                                        let v1553 = &C::gpr_to_gpr_mem(ctx, v1007);

16775

                                        let v1554 = constructor_x64_cvtsi2ss(ctx, I32, v1553);

16776

                                        let v1555 = constructor_output_xmm(ctx, v1554);

16777

                                        // Rule at src/isa/x64/lower.isle line 2865.

16778

                                        return Some(v1555);

16779

16780

                                    I16 => {

16781

                                        let v1007 = constructor_extend_to_gpr(

16782

                                            ctx,

16783

                                            v301,

16784

                                            I32,

16785

                                            &ExtendKind::Sign,

16786

);

16787

                                        let v1553 = &C::gpr_to_gpr_mem(ctx, v1007);

16788

                                        let v1554 = constructor_x64_cvtsi2ss(ctx, I32, v1553);

16789

                                        let v1555 = constructor_output_xmm(ctx, v1554);

16790

                                        // Rule at src/isa/x64/lower.isle line 2868.

16791

                                        return Some(v1555);

16792

16793

                                    _ => {}

16794

16795

                                let v1556 = C::ty_int(ctx, v529);

16796

                                if let Some(v1557) = v1556 {

16797

                                    let v1558 = C::fits_in_64(ctx, v1557);

16798

                                    if let Some(v1559) = v1558 {

16799

                                        let v1560 = &constructor_put_in_gpr_mem(ctx, v301);

16800

                                        let v1561 = constructor_x64_cvtsi2ss(ctx, v1559, v1560);

16801

                                        let v1562 = constructor_output_xmm(ctx, v1561);

16802

                                        // Rule at src/isa/x64/lower.isle line 2871.

16803

                                        return Some(v1562);

16804

16805

16806

16807

                            F64 => {

16808

                                let v529 = C::value_type(ctx, v301);

16809

                                match v529 {

16810

                                    I8 => {

16811

                                        let v1007 = constructor_extend_to_gpr(

16812

                                            ctx,

16813

                                            v301,

16814

                                            I32,

16815

                                            &ExtendKind::Sign,

16816

);

16817

                                        let v1553 = &C::gpr_to_gpr_mem(ctx, v1007);

16818

                                        let v1563 = constructor_x64_cvtsi2sd(ctx, I32, v1553);

16819

                                        let v1564 = constructor_output_xmm(ctx, v1563);

16820

                                        // Rule at src/isa/x64/lower.isle line 2874.

16821

                                        return Some(v1564);

16822

16823

                                    I16 => {

16824

                                        let v1007 = constructor_extend_to_gpr(

16825

                                            ctx,

16826

                                            v301,

16827

                                            I32,

16828

                                            &ExtendKind::Sign,

16829

);

16830

                                        let v1553 = &C::gpr_to_gpr_mem(ctx, v1007);

16831

                                        let v1563 = constructor_x64_cvtsi2sd(ctx, I32, v1553);

16832

                                        let v1564 = constructor_output_xmm(ctx, v1563);

16833

                                        // Rule at src/isa/x64/lower.isle line 2877.

16834

                                        return Some(v1564);

16835

16836

                                    _ => {}

16837

16838

                                let v1556 = C::ty_int(ctx, v529);

16839

                                if let Some(v1557) = v1556 {

16840

                                    let v1558 = C::fits_in_64(ctx, v1557);

16841

                                    if let Some(v1559) = v1558 {

16842

                                        let v1560 = &constructor_put_in_gpr_mem(ctx, v301);

16843

                                        let v1565 = constructor_x64_cvtsi2sd(ctx, v1559, v1560);

16844

                                        let v1566 = constructor_output_xmm(ctx, v1565);

16845

                                        // Rule at src/isa/x64/lower.isle line 2880.

16846

                                        return Some(v1566);

16847

16848

16849

16850

                            _ => {}

16851

16852

16853

                    let v529 = C::value_type(ctx, v301);

16854

                    if v529 == I32X4 {

16855

                        let v459 = &C::put_in_xmm_mem(ctx, v301);

16856

                        let v1567 = constructor_x64_cvtdq2ps(ctx, v459);

16857

                        let v1568 = constructor_output_xmm(ctx, v1567);

16858

                        // Rule at src/isa/x64/lower.isle line 2883.

16859

                        return Some(v1568);

16860

16861

16862

                &Opcode::FcvtLowFromSint => {

16863

                    let v459 = &C::put_in_xmm_mem(ctx, v301);

16864

                    let v1569 = constructor_x64_cvtdq2pd(ctx, v459);

16865

                    let v1570 = constructor_output_xmm(ctx, v1569);

16866

                    // Rule at src/isa/x64/lower.isle line 2888.

16867

                    return Some(v1570);

16868

16869

                &Opcode::Isplit => {

16870

                    let v529 = C::value_type(ctx, v301);

16871

                    if v529 == I128 {

16872

                        let v305 = C::put_in_regs(ctx, v301);

16873

                        let v2211 = C::value_regs_get(ctx, v305, 0x0);

16874

                        let v2212 = C::value_regs_get(ctx, v305, 0x1);

16875

                        let v2213 = C::value_reg(ctx, v2211);

16876

                        let v2214 = C::value_reg(ctx, v2212);

16877

                        let v2215 = C::output_pair(ctx, v2213, v2214);

16878

                        // Rule at src/isa/x64/lower.isle line 3910.

16879

                        return Some(v2215);

16880

16881

16882

                _ => {}

16883

16884

16885

        &InstructionData::UnaryConst {

16886

            opcode: ref v1962,

16887

            constant_handle: v1963,

16888

        } => {

16889

            if let &Opcode::Vconst = v1962 {

16890

                let v1 = C::first_result(ctx, arg0);

16891

                if let Some(v2) = v1 {

16892

                    let v1964 = C::const_to_vconst(ctx, v1963);

16893

                    let v3 = C::value_type(ctx, v2);

16894

                    let v1965 = constructor_x64_xmm_load_const(ctx, v3, v1964);

16895

                    let v1966 = constructor_output_xmm(ctx, v1965);

16896

                    // Rule at src/isa/x64/lower.isle line 3548.

16897

                    return Some(v1966);

16898

16899

16900

16901

        &InstructionData::UnaryGlobalValue {

16902

            opcode: ref v1448,

16903

            global_value: v1449,

16904

        } => {

16905

            match v1448 {

16906

                &Opcode::SymbolValue => {

16907

                    let v1450 = C::symbol_value_data(ctx, v1449);

16908

                    if let Some(v1451) = v1450 {

16909

                        let v1455 = constructor_load_ext_name(ctx, v1451.0, v1451.2);

16910

                        let v1456 = constructor_output_reg(ctx, v1455);

16911

                        // Rule at src/isa/x64/lower.isle line 2718.

16912

                        return Some(v1456);

16913

16914

16915

                &Opcode::TlsValue => {

16916

                    let v1 = C::first_result(ctx, arg0);

16917

                    if let Some(v2) = v1 {

16918

                        let v1450 = C::symbol_value_data(ctx, v1449);

16919

                        if let Some(v1451) = v1450 {

16920

                            let v3 = C::value_type(ctx, v2);

16921

                            let v2216 = &C::tls_model(ctx, v3);

16922

                            match v2216 {

16923

                                &TlsModel::ElfGd => {

16924

                                    let v2217 = constructor_elf_tls_get_addr(ctx, v1451.0);

16925

                                    let v2218 = constructor_output_gpr(ctx, v2217);

16926

                                    // Rule at src/isa/x64/lower.isle line 3918.

16927

                                    return Some(v2218);

16928

16929

                                &TlsModel::Macho => {

16930

                                    let v2219 = constructor_macho_tls_get_addr(ctx, v1451.0);

16931

                                    let v2220 = constructor_output_gpr(ctx, v2219);

16932

                                    // Rule at src/isa/x64/lower.isle line 3921.

16933

                                    return Some(v2220);

16934

16935

                                &TlsModel::Coff => {

16936

                                    let v2221 = constructor_coff_tls_get_addr(ctx, v1451.0);

16937

                                    let v2222 = constructor_output_gpr(ctx, v2221);

16938

                                    // Rule at src/isa/x64/lower.isle line 3924.

16939

                                    return Some(v2222);

16940

16941

                                _ => {}

16942

16943

16944

16945

16946

                _ => {}

16947

16948

16949

        &InstructionData::UnaryIeee32 {

16950

            opcode: ref v18,

16951

            imm: v19,

16952

        } => {

16953

            if let &Opcode::F32const = v18 {

16954

                let v20 = C::u32_from_ieee32(ctx, v19);

16955

                let v22 = C::u32_as_u64(ctx, v20);

16956

                let v23 = constructor_imm(ctx, F32, v22);

16957

                let v24 = constructor_output_reg(ctx, v23);

16958

                // Rule at src/isa/x64/lower.isle line 27.

16959

                return Some(v24);

16960

16961

16962

        &InstructionData::UnaryIeee64 {

16963

            opcode: ref v25,

16964

            imm: v26,

16965

        } => {

16966

            if let &Opcode::F64const = v25 {

16967

                let v27 = C::u64_from_ieee64(ctx, v26);

16968

                let v29 = constructor_imm(ctx, F64, v27);

16969

                let v30 = constructor_output_reg(ctx, v29);

16970

                // Rule at src/isa/x64/lower.isle line 32.

16971

                return Some(v30);

16972

16973

16974

        &InstructionData::UnaryImm {

16975

            opcode: ref v7,

16976

            imm: v8,

16977

        } => {

16978

            if let &Opcode::Iconst = v7 {

16979

                let v1 = C::first_result(ctx, arg0);

16980

                if let Some(v2) = v1 {

16981

                    let v3 = C::value_type(ctx, v2);

16982

                    if v3 == I128 {

16983

                        let v9 = C::u64_from_imm64(ctx, v8);

16984

                        let v13 = constructor_imm(ctx, I64, v9);

16985

                        let v15 = constructor_imm(ctx, I64, 0x0);

16986

                        let v16 = C::value_regs(ctx, v13, v15);

16987

                        let v17 = C::output(ctx, v16);

16988

                        // Rule at src/isa/x64/lower.isle line 20.

16989

                        return Some(v17);

16990

16991

                    let v4 = C::fits_in_64(ctx, v3);

16992

                    if let Some(v5) = v4 {

16993

                        let v9 = C::u64_from_imm64(ctx, v8);

16994

                        let v10 = constructor_imm(ctx, v5, v9);

16995

                        let v11 = constructor_output_reg(ctx, v10);

16996

                        // Rule at src/isa/x64/lower.isle line 15.

16997

                        return Some(v11);

16998

16999

17000

17001

17002

        _ => {}

17003

17004

    None

17005

17006

17007

// Generated as internal constructor for term lower_branch.

17008

pub fn constructor_lower_branch<C: Context>(

17009

    ctx: &mut C,

17010

    arg0: Inst,

17011

    arg1: &MachLabelSlice,

17012

) -> Option<Unit> {

17013

    let v1 = &C::inst_data(ctx, arg0);

17014

    match v1 {

17015

        &InstructionData::BranchTable {

17016

            opcode: ref v55,

17017

            arg: v56,

17018

            table: v57,

17019

        } => {

17020

            if let &Opcode::BrTable = v55 {

17021

                let v59 = C::jump_table_targets(ctx, arg1);

17022

                if let Some(v60) = v59 {

17023

                    let v58 = C::value_type(ctx, v56);

17024

                    let v63 = &C::raw_operand_size_of_type(ctx, v58);

17025

                    let v64 = C::jump_table_size(ctx, &v60.1);

17026

                    let v65 = C::u32_as_u64(ctx, v64);

17027

                    let v66 = constructor_imm(ctx, v58, v65);

17028

                    let v69 = constructor_extend_to_gpr(ctx, v56, I64, &ExtendKind::Zero);

17029

                    let v70 = &constructor_reg_to_gpr_mem_imm(ctx, v66);

17030

                    let v71 = &constructor_x64_cmp(ctx, v63, v70, v69);

17031

                    let v73 = &C::gpr_to_gpr_mem(ctx, v69);

17032

                    let v74 = C::gpr_new(ctx, v66);

17033

                    let v75 = &constructor_cmove(ctx, v58, &CC::B, v73, v74);

17034

                    let v76 = constructor_with_flags_reg(ctx, v71, v75);

17035

                    let v77 = C::gpr_new(ctx, v76);

17036

                    let v78 = &constructor_jmp_table_seq(ctx, v58, v77, v60.0, &v60.1);

17037

                    let v79 = constructor_emit_side_effect(ctx, v78);

17038

                    // Rule at src/isa/x64/lower.isle line 2839.

17039

                    return Some(v79);

17040

17041

17042

17043

        &InstructionData::Brif {

17044

            opcode: ref v9,

17045

            arg: v10,

17046

            blocks: ref v11,

17047

        } => {

17048

            if let &Opcode::Brif = v9 {

17049

                let v26 = C::two_targets(ctx, arg1);

17050

                if let Some(v27) = v26 {

17051

                    let v12 = C::maybe_uextend(ctx, v10);

17052

                    if let Some(v13) = v12 {

17053

                        let v14 = C::def_inst(ctx, v13);

17054

                        if let Some(v15) = v14 {

17055

                            let v16 = &C::inst_data(ctx, v15);

17056

                            match v16 {

17057

                                &InstructionData::FloatCompare {

17058

                                    opcode: ref v33,

17059

                                    args: ref v34,

17060

                                    cond: ref v35,

17061

                                } => {

17062

                                    if let &Opcode::Fcmp = v33 {

17063

                                        let v36 = C::unpack_value_array_2(ctx, v34);

17064

                                        let v39 = &constructor_emit_fcmp(ctx, v35, v36.0, v36.1);

17065

                                        let v40 =

17066

                                            &constructor_jmp_cond_fcmp(ctx, v39, v27.0, v27.1);

17067

                                        let v41 = constructor_emit_side_effect(ctx, v40);

17068

                                        // Rule at src/isa/x64/lower.isle line 2800.

17069

                                        return Some(v41);

17070

17071

17072

                                &InstructionData::IntCompare {

17073

                                    opcode: ref v17,

17074

                                    args: ref v18,

17075

                                    cond: ref v19,

17076

                                } => {

17077

                                    if let &Opcode::Icmp = v17 {

17078

                                        let v20 = C::unpack_value_array_2(ctx, v18);

17079

                                        let v30 = &constructor_emit_cmp(ctx, v19, v20.0, v20.1);

17080

                                        let v31 =

17081

                                            &constructor_jmp_cond_icmp(ctx, v30, v27.0, v27.1);

17082

                                        let v32 = constructor_emit_side_effect(ctx, v31);

17083

                                        // Rule at src/isa/x64/lower.isle line 2797.

17084

                                        return Some(v32);

17085

17086

17087

                                _ => {}

17088

17089

17090

17091

                    let v42 = C::value_type(ctx, v10);

17092

                    if v42 == I128 {

17093

                        let v44 = C::put_in_regs(ctx, v10);

17094

                        let v45 = &constructor_cmp_zero_i128(ctx, &CC::Z, v44);

17095

                        let v46 = &constructor_jmp_cond_icmp(ctx, v45, v27.0, v27.1);

17096

                        let v47 = constructor_emit_side_effect(ctx, v46);

17097

                        // Rule at src/isa/x64/lower.isle line 2803.

17098

                        return Some(v47);

17099

17100

                    let v48 = C::ty_int_bool_or_ref(ctx, v42);

17101

                    if let Some(v49) = v48 {

17102

                        let v50 = &constructor_cmp_zero_int_bool_ref(ctx, v10);

17103

                        let v52 = &constructor_jmp_cond(ctx, &CC::NZ, v27.0, v27.1);

17104

                        let v53 = &constructor_with_flags_side_effect(ctx, v50, v52);

17105

                        let v54 = constructor_emit_side_effect(ctx, v53);

17106

                        // Rule at src/isa/x64/lower.isle line 2807.

17107

                        return Some(v54);

17108

17109

17110

17111

17112

        &InstructionData::Jump {

17113

            opcode: ref v2,

17114

            destination: v3,

17115

        } => {

17116

            if let &Opcode::Jump = v2 {

17117

                let v5 = C::single_target(ctx, arg1);

17118

                if let Some(v6) = v5 {

17119

                    let v7 = &constructor_jmp_known(ctx, v6);

17120

                    let v8 = constructor_emit_side_effect(ctx, v7);

17121

                    // Rule at src/isa/x64/lower.isle line 2792.

17122

                    return Some(v8);

17123

17124

17125

17126

        _ => {}

17127

17128

    None

17129

17130

17131

// Generated as internal constructor for term sse_and.

17132

pub fn constructor_sse_and<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {

17133

    match arg0 {

17134

        F32 => {

17135

            let v3 = constructor_x64_andps(ctx, arg1, arg2);

17136

            // Rule at src/isa/x64/lower.isle line 225.

17137

            return v3;

17138

17139

        F64 => {

17140

            let v4 = constructor_x64_andpd(ctx, arg1, arg2);

17141

            // Rule at src/isa/x64/lower.isle line 226.

17142

            return v4;

17143

17144

        F32X4 => {

17145

            let v3 = constructor_x64_andps(ctx, arg1, arg2);

17146

            // Rule at src/isa/x64/lower.isle line 223.

17147

            return v3;

17148

17149

        F64X2 => {

17150

            let v4 = constructor_x64_andpd(ctx, arg1, arg2);

17151

            // Rule at src/isa/x64/lower.isle line 224.

17152

            return v4;

17153

17154

        _ => {}

17155

17156

    let v5 = C::multi_lane(ctx, arg0);

17157

    if let Some(v6) = v5 {

17158

        let v9 = constructor_x64_pand(ctx, arg1, arg2);

17159

        // Rule at src/isa/x64/lower.isle line 227.

17160

        return v9;

17161

17162

    unreachable!(

17163

        "no rule matched for term {} at {}; should it be partial?",

17164

        "sse_and", "src/isa/x64/lower.isle line 222"

17165

17166

17167

17168

// Generated as internal constructor for term sse_and_not.

17169

pub fn constructor_sse_and_not<C: Context>(

17170

    ctx: &mut C,

17171

    arg0: Type,

17172

    arg1: Xmm,

17173

    arg2: &XmmMem,

17174

) -> Xmm {

17175

    match arg0 {

17176

        F32X4 => {

17177

            let v3 = constructor_x64_andnps(ctx, arg1, arg2);

17178

            // Rule at src/isa/x64/lower.isle line 250.

17179

            return v3;

17180

17181

        F64X2 => {

17182

            let v4 = constructor_x64_andnpd(ctx, arg1, arg2);

17183

            // Rule at src/isa/x64/lower.isle line 251.

17184

            return v4;

17185

17186

        _ => {}

17187

17188

    let v5 = C::multi_lane(ctx, arg0);

17189

    if let Some(v6) = v5 {

17190

        let v9 = constructor_x64_pandn(ctx, arg1, arg2);

17191

        // Rule at src/isa/x64/lower.isle line 252.

17192

        return v9;

17193

17194

    unreachable!(

17195

        "no rule matched for term {} at {}; should it be partial?",

17196

        "sse_and_not", "src/isa/x64/lower.isle line 249"

17197

17198

17199

17200

// Generated as internal constructor for term sse_or.

17201

pub fn constructor_sse_or<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {

17202

    match arg0 {

17203

        F32 => {

17204

            let v3 = constructor_x64_orps(ctx, arg1, arg2);

17205

            // Rule at src/isa/x64/lower.isle line 305.

17206

            return v3;

17207

17208

        F64 => {

17209

            let v4 = constructor_x64_orpd(ctx, arg1, arg2);

17210

            // Rule at src/isa/x64/lower.isle line 306.

17211

            return v4;

17212

17213

        F32X4 => {

17214

            let v3 = constructor_x64_orps(ctx, arg1, arg2);

17215

            // Rule at src/isa/x64/lower.isle line 303.

17216

            return v3;

17217

17218

        F64X2 => {

17219

            let v4 = constructor_x64_orpd(ctx, arg1, arg2);

17220

            // Rule at src/isa/x64/lower.isle line 304.

17221

            return v4;

17222

17223

        _ => {}

17224

17225

    let v5 = C::multi_lane(ctx, arg0);

17226

    if let Some(v6) = v5 {

17227

        let v9 = constructor_x64_por(ctx, arg1, arg2);

17228

        // Rule at src/isa/x64/lower.isle line 307.

17229

        return v9;

17230

17231

    unreachable!(

17232

        "no rule matched for term {} at {}; should it be partial?",

17233

        "sse_or", "src/isa/x64/lower.isle line 302"

17234

17235

17236

17237

// Generated as internal constructor for term or_i128.

17238

pub fn constructor_or_i128<C: Context>(ctx: &mut C, arg0: ValueRegs, arg1: ValueRegs) -> ValueRegs {

17239

    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0);

17240

    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1);

17241

    let v6 = constructor_value_regs_get_gpr(ctx, arg1, 0x0);

17242

    let v7 = constructor_value_regs_get_gpr(ctx, arg1, 0x1);

17243

    let v9 = &C::gpr_to_gpr_mem_imm(ctx, v6);

17244

    let v10 = constructor_x64_or(ctx, I64, v3, v9);

17245

    let v11 = &C::gpr_to_gpr_mem_imm(ctx, v7);

17246

    let v12 = constructor_x64_or(ctx, I64, v5, v11);

17247

    let v13 = constructor_value_gprs(ctx, v10, v12);

17248

    // Rule at src/isa/x64/lower.isle line 316.

17249

    return v13;

17250

17251

17252

// Generated as internal constructor for term shl_i128.

17253

pub fn constructor_shl_i128<C: Context>(ctx: &mut C, arg0: ValueRegs, arg1: Gpr) -> ValueRegs {

17254

    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0);

17255

    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1);

17256

    let v7 = &C::gpr_to_imm8_gpr(ctx, arg1);

17257

    let v8 = constructor_x64_shl(ctx, I64, v3, v7);

17258

    let v9 = &C::gpr_to_imm8_gpr(ctx, arg1);

17259

    let v10 = constructor_x64_shl(ctx, I64, v5, v9);

17260

    let v12 = constructor_imm(ctx, I64, 0x40);

17261

    let v13 = C::gpr_new(ctx, v12);

17262

    let v14 = &C::gpr_to_gpr_mem_imm(ctx, arg1);

17263

    let v15 = constructor_x64_sub(ctx, I64, v13, v14);

17264

    let v16 = &C::gpr_to_imm8_gpr(ctx, v15);

17265

    let v17 = constructor_x64_shr(ctx, I64, v3, v16);

17266

    let v19 = constructor_imm(ctx, I64, 0x0);

17267

    let v20 = C::gpr_new(ctx, v19);

17268

    let v23 = RegMemImm::Imm { simm32: 0x7F };

17269

    let v24 = &C::gpr_mem_imm_new(ctx, &v23);

17270

    let v25 = &constructor_x64_test(ctx, &OperandSize::Size64, v24, arg1);

17271

    let v27 = &C::gpr_to_gpr_mem(ctx, v20);

17272

    let v28 = &constructor_cmove(ctx, I64, &CC::Z, v27, v17);

17273

    let v29 = constructor_with_flags_reg(ctx, v25, v28);

17274

    let v30 = C::gpr_new(ctx, v29);

17275

    let v31 = &C::gpr_to_gpr_mem_imm(ctx, v10);

17276

    let v32 = constructor_x64_or(ctx, I64, v30, v31);

17277

    let v34 = RegMemImm::Imm { simm32: 0x40 };

17278

    let v35 = &C::gpr_mem_imm_new(ctx, &v34);

17279

    let v36 = &constructor_x64_test(ctx, &OperandSize::Size64, v35, arg1);

17280

    let v37 = &C::gpr_to_gpr_mem(ctx, v8);

17281

    let v38 = &constructor_cmove(ctx, I64, &CC::Z, v37, v20);

17282

    let v39 = &C::gpr_to_gpr_mem(ctx, v32);

17283

    let v40 = &constructor_cmove(ctx, I64, &CC::Z, v39, v8);

17284

    let v41 = &constructor_consumes_flags_concat(ctx, v38, v40);

17285

    let v42 = constructor_with_flags(ctx, v36, v41);

17286

    // Rule at src/isa/x64/lower.isle line 379.

17287

    return v42;

17288

17289

17290

// Generated as internal constructor for term ishl_i8x16_mask.

17291

pub fn constructor_ishl_i8x16_mask<C: Context>(ctx: &mut C, arg0: &RegMemImm) -> SyntheticAmode {

17292

    match arg0 {

17293

        &RegMemImm::Reg { reg: v3 } => {

17294

            let v4 = &C::ishl_i8x16_mask_table(ctx);

17295

            let v6 = constructor_x64_lea(ctx, I64, v4);

17296

            let v7 = C::gpr_new(ctx, v3);

17297

            let v9 = &C::imm8_to_imm8_gpr(ctx, 0x4);

17298

            let v10 = constructor_x64_shl(ctx, I64, v7, v9);

17299

            let v13 = C::mem_flags_trusted(ctx);

17300

            let v14 = Amode::ImmRegRegShift {

17301

                simm32: 0x0,

17302

                base: v6,

17303

                index: v10,

17304

                shift: 0x0,

17305

                flags: v13,

17306

};

17307

            let v15 = &C::amode_to_synthetic_amode(ctx, &v14);

17308

            // Rule at src/isa/x64/lower.isle line 453.

17309

            return v15.clone();

17310

17311

        &RegMemImm::Mem { addr: ref v16 } => {

17312

            let v18 = constructor_x64_load(ctx, I64, v16, &ExtKind::None);

17313

            let v19 = RegMemImm::Reg { reg: v18 };

17314

            let v20 = &constructor_ishl_i8x16_mask(ctx, &v19);

17315

            // Rule at src/isa/x64/lower.isle line 464.

17316

            return v20.clone();

17317

17318

        &RegMemImm::Imm { simm32: v1 } => {

17319

            let v2 = &C::ishl_i8x16_mask_for_const(ctx, v1);

17320

            // Rule at src/isa/x64/lower.isle line 444.

17321

            return v2.clone();

17322

17323

        _ => {}

17324

17325

    unreachable!(

17326

        "no rule matched for term {} at {}; should it be partial?",

17327

        "ishl_i8x16_mask", "src/isa/x64/lower.isle line 438"

17328

17329

17330

17331

// Generated as internal constructor for term shr_i128.

17332

pub fn constructor_shr_i128<C: Context>(ctx: &mut C, arg0: ValueRegs, arg1: Gpr) -> ValueRegs {

17333

    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0);

17334

    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1);

17335

    let v7 = &C::gpr_to_imm8_gpr(ctx, arg1);

17336

    let v8 = constructor_x64_shr(ctx, I64, v3, v7);

17337

    let v9 = &C::gpr_to_imm8_gpr(ctx, arg1);

17338

    let v10 = constructor_x64_shr(ctx, I64, v5, v9);

17339

    let v12 = constructor_imm(ctx, I64, 0x40);

17340

    let v13 = C::gpr_new(ctx, v12);

17341

    let v14 = &C::gpr_to_gpr_mem_imm(ctx, arg1);

17342

    let v15 = constructor_x64_sub(ctx, I64, v13, v14);

17343

    let v16 = &C::gpr_to_imm8_gpr(ctx, v15);

17344

    let v17 = constructor_x64_shl(ctx, I64, v5, v16);

17345

    let v19 = constructor_imm(ctx, I64, 0x0);

17346

    let v20 = C::gpr_new(ctx, v19);

17347

    let v23 = RegMemImm::Imm { simm32: 0x7F };

17348

    let v24 = &C::gpr_mem_imm_new(ctx, &v23);

17349

    let v25 = &constructor_x64_test(ctx, &OperandSize::Size64, v24, arg1);

17350

    let v27 = &C::gpr_to_gpr_mem(ctx, v20);

17351

    let v28 = &constructor_cmove(ctx, I64, &CC::Z, v27, v17);

17352

    let v29 = constructor_with_flags_reg(ctx, v25, v28);

17353

    let v30 = C::gpr_new(ctx, v29);

17354

    let v31 = &C::gpr_to_gpr_mem_imm(ctx, v8);

17355

    let v32 = constructor_x64_or(ctx, I64, v30, v31);

17356

    let v34 = RegMemImm::Imm { simm32: 0x40 };

17357

    let v35 = &C::gpr_mem_imm_new(ctx, &v34);

17358

    let v36 = &constructor_x64_test(ctx, &OperandSize::Size64, v35, arg1);

17359

    let v37 = &C::gpr_to_gpr_mem(ctx, v32);

17360

    let v38 = &constructor_cmove(ctx, I64, &CC::Z, v37, v10);

17361

    let v39 = &C::gpr_to_gpr_mem(ctx, v10);

17362

    let v40 = &constructor_cmove(ctx, I64, &CC::Z, v39, v20);

17363

    let v41 = &constructor_consumes_flags_concat(ctx, v38, v40);

17364

    let v42 = constructor_with_flags(ctx, v36, v41);

17365

    // Rule at src/isa/x64/lower.isle line 489.

17366

    return v42;

17367

17368

17369

// Generated as internal constructor for term ushr_i8x16_mask.

17370

pub fn constructor_ushr_i8x16_mask<C: Context>(ctx: &mut C, arg0: &RegMemImm) -> SyntheticAmode {

17371

    match arg0 {

17372

        &RegMemImm::Reg { reg: v3 } => {

17373

            let v4 = &C::ushr_i8x16_mask_table(ctx);

17374

            let v6 = constructor_x64_lea(ctx, I64, v4);

17375

            let v7 = C::gpr_new(ctx, v3);

17376

            let v9 = &C::imm8_to_imm8_gpr(ctx, 0x4);

17377

            let v10 = constructor_x64_shl(ctx, I64, v7, v9);

17378

            let v13 = C::mem_flags_trusted(ctx);

17379

            let v14 = Amode::ImmRegRegShift {

17380

                simm32: 0x0,

17381

                base: v6,

17382

                index: v10,

17383

                shift: 0x0,

17384

                flags: v13,

17385

};

17386

            let v15 = &C::amode_to_synthetic_amode(ctx, &v14);

17387

            // Rule at src/isa/x64/lower.isle line 558.

17388

            return v15.clone();

17389

17390

        &RegMemImm::Mem { addr: ref v16 } => {

17391

            let v18 = constructor_x64_load(ctx, I64, v16, &ExtKind::None);

17392

            let v19 = RegMemImm::Reg { reg: v18 };

17393

            let v20 = &constructor_ushr_i8x16_mask(ctx, &v19);

17394

            // Rule at src/isa/x64/lower.isle line 570.

17395

            return v20.clone();

17396

17397

        &RegMemImm::Imm { simm32: v1 } => {

17398

            let v2 = &C::ushr_i8x16_mask_for_const(ctx, v1);

17399

            // Rule at src/isa/x64/lower.isle line 549.

17400

            return v2.clone();

17401

17402

        _ => {}

17403

17404

    unreachable!(

17405

        "no rule matched for term {} at {}; should it be partial?",

17406

        "ushr_i8x16_mask", "src/isa/x64/lower.isle line 543"

17407

17408

17409

17410

// Generated as internal constructor for term mask_xmm_shift.

17411

pub fn constructor_mask_xmm_shift<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> RegMemImm {

17412

    let v10 = C::def_inst(ctx, arg1);

17413

    if let Some(v11) = v10 {

17414

        let v12 = &C::inst_data(ctx, v11);

17415

        if let &InstructionData::UnaryImm {

17416

            opcode: ref v13,

17417

            imm: v14,

17418

        } = v12

17419

17420

            if let &Opcode::Iconst = v13 {

17421

                let v15 = C::shift_amount_masked(ctx, arg0, v14);

17422

                let v16 = RegMemImm::Imm { simm32: v15 };

17423

                // Rule at src/isa/x64/lower.isle line 587.

17424

                return v16;

17425

17426

17427

17428

    let v3 = constructor_put_in_gpr(ctx, arg1);

17429

    let v4 = C::shift_mask(ctx, arg0);

17430

    let v5 = RegMemImm::Imm { simm32: v4 };

17431

    let v6 = &C::gpr_mem_imm_new(ctx, &v5);

17432

    let v7 = constructor_x64_and(ctx, I64, v3, v6);

17433

    let v8 = C::gpr_to_reg(ctx, v7);

17434

    let v9 = &C::reg_to_reg_mem_imm(ctx, v8);

17435

    // Rule at src/isa/x64/lower.isle line 585.

17436

    return v9.clone();

17437

17438

17439

// Generated as internal constructor for term sar_i128.

17440

pub fn constructor_sar_i128<C: Context>(ctx: &mut C, arg0: ValueRegs, arg1: Gpr) -> ValueRegs {

17441

    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0);

17442

    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1);

17443

    let v7 = &C::gpr_to_imm8_gpr(ctx, arg1);

17444

    let v8 = constructor_x64_shr(ctx, I64, v3, v7);

17445

    let v9 = &C::gpr_to_imm8_gpr(ctx, arg1);

17446

    let v10 = constructor_x64_sar(ctx, I64, v5, v9);

17447

    let v12 = constructor_imm(ctx, I64, 0x40);

17448

    let v13 = C::gpr_new(ctx, v12);

17449

    let v14 = &C::gpr_to_gpr_mem_imm(ctx, arg1);

17450

    let v15 = constructor_x64_sub(ctx, I64, v13, v14);

17451

    let v16 = &C::gpr_to_imm8_gpr(ctx, v15);

17452

    let v17 = constructor_x64_shl(ctx, I64, v5, v16);

17453

    let v20 = RegMemImm::Imm { simm32: 0x7F };

17454

    let v21 = &C::gpr_mem_imm_new(ctx, &v20);

17455

    let v22 = &constructor_x64_test(ctx, &OperandSize::Size64, v21, arg1);

17456

    let v25 = constructor_imm(ctx, I64, 0x0);

17457

    let v26 = &C::reg_to_gpr_mem(ctx, v25);

17458

    let v27 = &constructor_cmove(ctx, I64, &CC::Z, v26, v17);

17459

    let v28 = constructor_with_flags_reg(ctx, v22, v27);

17460

    let v29 = C::gpr_new(ctx, v28);

17461

    let v30 = &C::gpr_to_gpr_mem_imm(ctx, v29);

17462

    let v31 = constructor_x64_or(ctx, I64, v8, v30);

17463

    let v33 = &C::imm8_to_imm8_gpr(ctx, 0x3F);

17464

    let v34 = constructor_x64_sar(ctx, I64, v5, v33);

17465

    let v36 = RegMemImm::Imm { simm32: 0x40 };

17466

    let v37 = &C::gpr_mem_imm_new(ctx, &v36);

17467

    let v38 = &constructor_x64_test(ctx, &OperandSize::Size64, v37, arg1);

17468

    let v39 = &C::gpr_to_gpr_mem(ctx, v31);

17469

    let v40 = &constructor_cmove(ctx, I64, &CC::Z, v39, v10);

17470

    let v41 = &C::gpr_to_gpr_mem(ctx, v10);

17471

    let v42 = &constructor_cmove(ctx, I64, &CC::Z, v41, v34);

17472

    let v43 = &constructor_consumes_flags_concat(ctx, v40, v42);

17473

    let v44 = constructor_with_flags(ctx, v38, v43);

17474

    // Rule at src/isa/x64/lower.isle line 601.

17475

    return v44;

17476

17477

17478

// Generated as internal constructor for term sshr_i8x16_bigger_shift.

17479

pub fn constructor_sshr_i8x16_bigger_shift<C: Context>(

17480

    ctx: &mut C,

17481

    arg0: Type,

17482

    arg1: &RegMemImm,

17483

) -> XmmMemImm {

17484

    match arg1 {

17485

        &RegMemImm::Reg { reg: v7 } => {

17486

            let v8 = C::gpr_new(ctx, v7);

17487

            let v9 = RegMemImm::Imm { simm32: 0x8 };

17488

            let v10 = &C::gpr_mem_imm_new(ctx, &v9);

17489

            let v11 = constructor_x64_add(ctx, arg0, v8, v10);

17490

            let v12 = C::gpr_to_reg(ctx, v11);

17491

            let v13 = RegMemImm::Reg { reg: v12 };

17492

            let v14 = &constructor_mov_rmi_to_xmm(ctx, &v13);

17493

            // Rule at src/isa/x64/lower.isle line 669.

17494

            return v14.clone();

17495

17496

        &RegMemImm::Mem { addr: ref v15 } => {

17497

            let v17 = constructor_imm(ctx, arg0, 0x8);

17498

            let v18 = C::gpr_new(ctx, v17);

17499

            let v19 = &C::gpr_mem_imm_new(ctx, arg1);

17500

            let v20 = constructor_x64_add(ctx, arg0, v18, v19);

17501

            let v21 = C::gpr_to_reg(ctx, v20);

17502

            let v22 = RegMemImm::Reg { reg: v21 };

17503

            let v23 = &constructor_mov_rmi_to_xmm(ctx, &v22);

17504

            // Rule at src/isa/x64/lower.isle line 673.

17505

            return v23.clone();

17506

17507

        &RegMemImm::Imm { simm32: v2 } => {

17508

            let v4 = C::u32_add(ctx, v2, 0x8);

17509

            let v5 = RegMemImm::Imm { simm32: v4 };

17510

            let v6 = &C::xmm_mem_imm_new(ctx, &v5);

17511

            // Rule at src/isa/x64/lower.isle line 667.

17512

            return v6.clone();

17513

17514

        _ => {}

17515

17516

    unreachable!(

17517

        "no rule matched for term {} at {}; should it be partial?",

17518

        "sshr_i8x16_bigger_shift", "src/isa/x64/lower.isle line 666"

17519

17520

17521

17522

// Generated as internal constructor for term lower_bmask.

17523

pub fn constructor_lower_bmask<C: Context>(

17524

    ctx: &mut C,

17525

    arg0: Type,

17526

    arg1: Type,

17527

    arg2: ValueRegs,

17528

) -> ValueRegs {

17529

    if arg0 == I128 {

17530

        let v23 = constructor_lower_bmask(ctx, I64, arg1, arg2);

17531

        let v24 = constructor_value_regs_get_gpr(ctx, v23, 0x0);

17532

        let v25 = C::gpr_to_reg(ctx, v24);

17533

        let v26 = C::gpr_to_reg(ctx, v24);

17534

        let v27 = C::value_regs(ctx, v25, v26);

17535

        // Rule at src/isa/x64/lower.isle line 1146.

17536

        return v27;

17537

17538

    let v1 = C::fits_in_64(ctx, arg0);

17539

    if let Some(v2) = v1 {

17540

        if arg1 == I128 {

17541

            let v8 = constructor_value_regs_get_gpr(ctx, arg2, 0x0);

17542

            let v16 = constructor_value_regs_get_gpr(ctx, arg2, 0x1);

17543

            let v18 = &C::gpr_to_gpr_mem_imm(ctx, v16);

17544

            let v19 = constructor_x64_or(ctx, I64, v8, v18);

17545

            let v20 = C::gpr_to_reg(ctx, v19);

17546

            let v21 = C::value_reg(ctx, v20);

17547

            let v22 = constructor_lower_bmask(ctx, v2, I64, v21);

17548

            // Rule at src/isa/x64/lower.isle line 1138.

17549

            return v22;

17550

17551

        let v4 = C::fits_in_64(ctx, arg1);

17552

        if let Some(v5) = v4 {

17553

            let v8 = constructor_value_regs_get_gpr(ctx, arg2, 0x0);

17554

            let v9 = &constructor_x64_neg_paired(ctx, v5, v8);

17555

            let v10 = &C::gpr_to_gpr_mem_imm(ctx, v8);

17556

            let v11 = &constructor_x64_sbb_paired(ctx, v2, v8, v10);

17557

            let v12 = constructor_with_flags(ctx, v9, v11);

17558

            let v14 = C::value_regs_get(ctx, v12, 0x1);

17559

            let v15 = C::value_reg(ctx, v14);

17560

            // Rule at src/isa/x64/lower.isle line 1127.

17561

            return v15;

17562

17563

17564

    unreachable!(

17565

        "no rule matched for term {} at {}; should it be partial?",

17566

        "lower_bmask", "src/isa/x64/lower.isle line 1115"

17567

17568

17569

17570

// Generated as internal constructor for term i128_not.

17571

pub fn constructor_i128_not<C: Context>(ctx: &mut C, arg0: Value) -> ValueRegs {

17572

    let v1 = C::put_in_regs(ctx, arg0);

17573

    let v3 = constructor_value_regs_get_gpr(ctx, v1, 0x0);

17574

    let v5 = constructor_value_regs_get_gpr(ctx, v1, 0x1);

17575

    let v7 = constructor_x64_not(ctx, I64, v3);

17576

    let v8 = constructor_x64_not(ctx, I64, v5);

17577

    let v9 = constructor_value_gprs(ctx, v7, v8);

17578

    // Rule at src/isa/x64/lower.isle line 1169.

17579

    return v9;

17580

17581

17582

// Generated as internal constructor for term all_ones_or_all_zeros.

17583

pub fn constructor_all_ones_or_all_zeros<C: Context>(ctx: &mut C, arg0: Value) -> Option<bool> {

17584

    let v1 = C::def_inst(ctx, arg0);

17585

    if let Some(v2) = v1 {

17586

        let v3 = &C::inst_data(ctx, v2);

17587

        match v3 {

17588

            &InstructionData::FloatCompare {

17589

                opcode: ref v16,

17590

                args: ref v17,

17591

                cond: ref v18,

17592

            } => {

17593

                if let &Opcode::Fcmp = v16 {

17594

                    let v10 = C::value_type(ctx, arg0);

17595

                    let v11 = C::multi_lane(ctx, v10);

17596

                    if let Some(v12) = v11 {

17597

                        // Rule at src/isa/x64/lower.isle line 1217.

17598

                        return Some(true);

17599

17600

17601

17602

            &InstructionData::IntCompare {

17603

                opcode: ref v4,

17604

                args: ref v5,

17605

                cond: ref v6,

17606

            } => {

17607

                if let &Opcode::Icmp = v4 {

17608

                    let v10 = C::value_type(ctx, arg0);

17609

                    let v11 = C::multi_lane(ctx, v10);

17610

                    if let Some(v12) = v11 {

17611

                        // Rule at src/isa/x64/lower.isle line 1216.

17612

                        return Some(true);

17613

17614

17615

17616

            &InstructionData::UnaryConst {

17617

                opcode: ref v22,

17618

                constant_handle: v23,

17619

            } => {

17620

                if let &Opcode::Vconst = v22 {

17621

                    let v24 = C::vconst_all_ones_or_all_zeros(ctx, v23);

17622

                    if let Some(v25) = v24 {

17623

                        // Rule at src/isa/x64/lower.isle line 1218.

17624

                        return Some(true);

17625

17626

17627

17628

            _ => {}

17629

17630

17631

    None

17632

17633

17634

// Generated as internal constructor for term vec_insert_lane.

17635

pub fn constructor_vec_insert_lane<C: Context>(

17636

    ctx: &mut C,

17637

    arg0: Type,

17638

    arg1: Xmm,

17639

    arg2: &RegMem,

17640

    arg3: u8,

17641

) -> Xmm {

17642

    match arg0 {

17643

        I8X16 => {

17644

            let v4 = &C::reg_mem_to_gpr_mem(ctx, arg2);

17645

            let v5 = constructor_x64_pinsrb(ctx, arg1, v4, arg3);

17646

            // Rule at src/isa/x64/lower.isle line 1250.

17647

            return v5;

17648

17649

        I16X8 => {

17650

            let v4 = &C::reg_mem_to_gpr_mem(ctx, arg2);

17651

            let v6 = constructor_x64_pinsrw(ctx, arg1, v4, arg3);

17652

            // Rule at src/isa/x64/lower.isle line 1254.

17653

            return v6;

17654

17655

        I32X4 => {

17656

            let v4 = &C::reg_mem_to_gpr_mem(ctx, arg2);

17657

            let v7 = constructor_x64_pinsrd(ctx, arg1, v4, arg3);

17658

            // Rule at src/isa/x64/lower.isle line 1258.

17659

            return v7;

17660

17661

        I64X2 => {

17662

            let v4 = &C::reg_mem_to_gpr_mem(ctx, arg2);

17663

            let v8 = constructor_x64_pinsrq(ctx, arg1, v4, arg3);

17664

            // Rule at src/isa/x64/lower.isle line 1262.

17665

            return v8;

17666

17667

        F32X4 => {

17668

            let v9 = &C::reg_mem_to_xmm_mem(ctx, arg2);

17669

            let v10 = C::sse_insertps_lane_imm(ctx, arg3);

17670

            let v11 = constructor_x64_insertps(ctx, arg1, v9, v10);

17671

            // Rule at src/isa/x64/lower.isle line 1266.

17672

            return v11;

17673

17674

        F64X2 => {

17675

            match arg3 {

17676

                0x0 => {

17677

                    match arg2 {

17678

                        &RegMem::Reg { reg: v12 } => {

17679

                            let v13 = C::xmm_new(ctx, v12);

17680

                            let v14 = constructor_x64_movsd_regmove(ctx, arg1, v13);

17681

                            // Rule at src/isa/x64/lower.isle line 1278.

17682

                            return v14;

17683

17684

                        &RegMem::Mem { addr: ref v15 } => {

17685

                            let v16 = constructor_x64_movsd_load(ctx, v15);

17686

                            let v17 = constructor_x64_movsd_regmove(ctx, arg1, v16);

17687

                            // Rule at src/isa/x64/lower.isle line 1280.

17688

                            return v17;

17689

17690

                        _ => {}

17691

17692

17693

                0x1 => {

17694

                    let v9 = &C::reg_mem_to_xmm_mem(ctx, arg2);

17695

                    let v18 = constructor_x64_movlhps(ctx, arg1, v9);

17696

                    // Rule at src/isa/x64/lower.isle line 1288.

17697

                    return v18;

17698

17699

                _ => {}

17700

17701

17702

        _ => {}

17703

17704

    unreachable!(

17705

        "no rule matched for term {} at {}; should it be partial?",

17706

        "vec_insert_lane", "src/isa/x64/lower.isle line 1247"

17707

17708

17709

17710

// Generated as internal constructor for term cmp_and_choose.

17711

pub fn constructor_cmp_and_choose<C: Context>(

17712

    ctx: &mut C,

17713

    arg0: Type,

17714

    arg1: &CC,

17715

    arg2: Value,

17716

    arg3: Value,

17717

) -> ValueRegs {

17718

    let v1 = C::fits_in_64(ctx, arg0);

17719

    if let Some(v2) = v1 {

17720

        let v6 = &C::raw_operand_size_of_type(ctx, v2);

17721

        let v7 = C::put_in_reg(ctx, arg2);

17722

        let v8 = C::put_in_reg(ctx, arg3);

17723

        let v9 = &constructor_reg_to_gpr_mem_imm(ctx, v7);

17724

        let v10 = C::gpr_new(ctx, v8);

17725

        let v11 = &constructor_x64_cmp(ctx, v6, v9, v10);

17726

        let v12 = &C::reg_to_gpr_mem(ctx, v8);

17727

        let v13 = C::gpr_new(ctx, v7);

17728

        let v14 = &constructor_cmove(ctx, v2, arg1, v12, v13);

17729

        let v15 = constructor_with_flags_reg(ctx, v11, v14);

17730

        let v16 = C::value_reg(ctx, v15);

17731

        // Rule at src/isa/x64/lower.isle line 1296.

17732

        return v16;

17733

17734

    unreachable!(

17735

        "no rule matched for term {} at {}; should it be partial?",

17736

        "cmp_and_choose", "src/isa/x64/lower.isle line 1295"

17737

17738

17739

17740

// Generated as internal constructor for term lower_select_fcmp.

17741

pub fn constructor_lower_select_fcmp<C: Context>(

17742

    ctx: &mut C,

17743

    arg0: Type,

17744

    arg1: &FcmpCondResult,

17745

    arg2: Value,

17746

    arg3: Value,

17747

) -> InstOutput {

17748

    match arg1 {

17749

        &FcmpCondResult::Condition {

17750

            producer: ref v2,

17751

            cc: ref v3,

17752

        } => {

17753

            let v6 = &constructor_cmove_from_values(ctx, arg0, v3, arg2, arg3);

17754

            let v7 = constructor_with_flags(ctx, v2, v6);

17755

            let v8 = C::output(ctx, v7);

17756

            // Rule at src/isa/x64/lower.isle line 1588.

17757

            return v8;

17758

17759

        &FcmpCondResult::OrCondition {

17760

            producer: ref v9,

17761

            cc1: ref v10,

17762

            cc2: ref v11,

17763

        } => {

17764

            let v12 = &constructor_cmove_or_from_values(ctx, arg0, v10, v11, arg2, arg3);

17765

            let v13 = constructor_with_flags(ctx, v9, v12);

17766

            let v14 = C::output(ctx, v13);

17767

            // Rule at src/isa/x64/lower.isle line 1590.

17768

            return v14;

17769

17770

        _ => {}

17771

17772

    unreachable!(

17773

        "no rule matched for term {} at {}; should it be partial?",

17774

        "lower_select_fcmp", "src/isa/x64/lower.isle line 1587"

17775

17776

17777

17778

// Generated as internal constructor for term do_clz.

17779

pub fn constructor_do_clz<C: Context>(ctx: &mut C, arg0: Type, arg1: Type, arg2: Gpr) -> Gpr {

17780

    let v5 = constructor_imm_i64(ctx, I64, -0x1);

17781

    let v6 = C::gpr_new(ctx, v5);

17782

    let v7 = constructor_bsr_or_else(ctx, arg0, arg2, v6);

17783

    let v8 = C::gpr_to_reg(ctx, v7);

17784

    let v9 = C::ty_bits_u64(ctx, arg1);

17785

    let v11 = C::u64_sub(ctx, v9, 0x1);

17786

    let v12 = constructor_imm(ctx, arg0, v11);

17787

    let v13 = C::gpr_new(ctx, v12);

17788

    let v14 = &constructor_reg_to_gpr_mem_imm(ctx, v8);

17789

    let v15 = constructor_x64_sub(ctx, arg0, v13, v14);

17790

    // Rule at src/isa/x64/lower.isle line 1656.

17791

    return v15;

17792

17793

17794

// Generated as internal constructor for term do_ctz.

17795

pub fn constructor_do_ctz<C: Context>(ctx: &mut C, arg0: Type, arg1: Type, arg2: Gpr) -> Gpr {

17796

    let v4 = C::ty_bits_u64(ctx, arg1);

17797

    let v5 = constructor_imm(ctx, I64, v4);

17798

    let v6 = C::gpr_new(ctx, v5);

17799

    let v7 = constructor_bsf_or_else(ctx, arg0, arg2, v6);

17800

    // Rule at src/isa/x64/lower.isle line 1699.

17801

    return v7;

17802

17803

17804

// Generated as internal constructor for term do_popcnt.

17805

pub fn constructor_do_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

17806

    match arg0 {

17807

        I32 => {

17808

            let v4 = Imm8Reg::Imm8 { imm: 0x1 };

17809

            let v5 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);

17810

            let v47 = constructor_x64_shr(ctx, I32, arg1, v5);

17811

            let v49 = constructor_imm(ctx, I32, 0x77777777);

17812

            let v50 = C::gpr_new(ctx, v49);

17813

            let v51 = &C::gpr_to_gpr_mem_imm(ctx, v50);

17814

            let v52 = constructor_x64_and(ctx, I32, v47, v51);

17815

            let v53 = &C::gpr_to_gpr_mem_imm(ctx, v52);

17816

            let v54 = constructor_x64_sub(ctx, I32, arg1, v53);

17817

            let v14 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);

17818

            let v55 = constructor_x64_shr(ctx, I32, v52, v14);

17819

            let v56 = &C::gpr_to_gpr_mem_imm(ctx, v50);

17820

            let v57 = constructor_x64_and(ctx, I32, v55, v56);

17821

            let v58 = &C::gpr_to_gpr_mem_imm(ctx, v57);

17822

            let v59 = constructor_x64_sub(ctx, I32, v54, v58);

17823

            let v20 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);

17824

            let v60 = constructor_x64_shr(ctx, I32, v57, v20);

17825

            let v61 = &C::gpr_to_gpr_mem_imm(ctx, v50);

17826

            let v62 = constructor_x64_and(ctx, I32, v60, v61);

17827

            let v63 = &C::gpr_to_gpr_mem_imm(ctx, v62);

17828

            let v64 = constructor_x64_sub(ctx, I32, v59, v63);

17829

            let v27 = Imm8Reg::Imm8 { imm: 0x4 };

17830

            let v28 = &C::imm8_reg_to_imm8_gpr(ctx, &v27);

17831

            let v65 = constructor_x64_shr(ctx, I32, v64, v28);

17832

            let v66 = &C::gpr_to_gpr_mem_imm(ctx, v64);

17833

            let v67 = constructor_x64_add(ctx, I32, v65, v66);

17834

            let v69 = RegMemImm::Imm { simm32: 0xF0F0F0F };

17835

            let v70 = &C::gpr_mem_imm_new(ctx, &v69);

17836

            let v71 = constructor_x64_and(ctx, I32, v67, v70);

17837

            let v73 = RegMemImm::Imm { simm32: 0x1010101 };

17838

            let v74 = &C::gpr_mem_imm_new(ctx, &v73);

17839

            let v75 = constructor_x64_mul(ctx, I32, v71, v74);

17840

            let v77 = Imm8Reg::Imm8 { imm: 0x18 };

17841

            let v78 = &C::imm8_reg_to_imm8_gpr(ctx, &v77);

17842

            let v79 = constructor_x64_shr(ctx, I32, v75, v78);

17843

            // Rule at src/isa/x64/lower.isle line 1790.

17844

            return v79;

17845

17846

        I64 => {

17847

            let v4 = Imm8Reg::Imm8 { imm: 0x1 };

17848

            let v5 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);

17849

            let v6 = constructor_x64_shr(ctx, I64, arg1, v5);

17850

            let v8 = constructor_imm(ctx, I64, 0x7777777777777777);

17851

            let v9 = C::gpr_new(ctx, v8);

17852

            let v10 = &C::gpr_to_gpr_mem_imm(ctx, v9);

17853

            let v11 = constructor_x64_and(ctx, I64, v6, v10);

17854

            let v12 = &C::gpr_to_gpr_mem_imm(ctx, v11);

17855

            let v13 = constructor_x64_sub(ctx, I64, arg1, v12);

17856

            let v14 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);

17857

            let v15 = constructor_x64_shr(ctx, I64, v11, v14);

17858

            let v16 = &C::gpr_to_gpr_mem_imm(ctx, v9);

17859

            let v17 = constructor_x64_and(ctx, I64, v15, v16);

17860

            let v18 = &C::gpr_to_gpr_mem_imm(ctx, v17);

17861

            let v19 = constructor_x64_sub(ctx, I64, v13, v18);

17862

            let v20 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);

17863

            let v21 = constructor_x64_shr(ctx, I64, v17, v20);

17864

            let v22 = &C::gpr_to_gpr_mem_imm(ctx, v9);

17865

            let v23 = constructor_x64_and(ctx, I64, v21, v22);

17866

            let v24 = &C::gpr_to_gpr_mem_imm(ctx, v23);

17867

            let v25 = constructor_x64_sub(ctx, I64, v19, v24);

17868

            let v27 = Imm8Reg::Imm8 { imm: 0x4 };

17869

            let v28 = &C::imm8_reg_to_imm8_gpr(ctx, &v27);

17870

            let v29 = constructor_x64_shr(ctx, I64, v25, v28);

17871

            let v30 = &C::gpr_to_gpr_mem_imm(ctx, v25);

17872

            let v31 = constructor_x64_add(ctx, I64, v29, v30);

17873

            let v33 = constructor_imm(ctx, I64, 0xF0F0F0F0F0F0F0F);

17874

            let v34 = C::gpr_new(ctx, v33);

17875

            let v35 = &C::gpr_to_gpr_mem_imm(ctx, v34);

17876

            let v36 = constructor_x64_and(ctx, I64, v31, v35);

17877

            let v38 = constructor_imm(ctx, I64, 0x101010101010101);

17878

            let v39 = C::gpr_new(ctx, v38);

17879

            let v40 = &C::gpr_to_gpr_mem_imm(ctx, v39);

17880

            let v41 = constructor_x64_mul(ctx, I64, v36, v40);

17881

            let v43 = Imm8Reg::Imm8 { imm: 0x38 };

17882

            let v44 = &C::imm8_reg_to_imm8_gpr(ctx, &v43);

17883

            let v45 = constructor_x64_shr(ctx, I64, v41, v44);

17884

            // Rule at src/isa/x64/lower.isle line 1747.

17885

            return v45;

17886

17887

        _ => {}

17888

17889

    unreachable!(

17890

        "no rule matched for term {} at {}; should it be partial?",

17891

        "do_popcnt", "src/isa/x64/lower.isle line 1746"

17892

17893

17894

17895

// Generated as internal constructor for term do_bitrev8.

17896

pub fn constructor_do_bitrev8<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

17897

    let v2 = C::ty_mask(ctx, arg0);

17898

    let v4 = C::u64_and(ctx, v2, 0x5555555555555555);

17899

    let v5 = constructor_imm(ctx, arg0, v4);

17900

    let v6 = C::gpr_new(ctx, v5);

17901

    let v7 = &C::gpr_to_gpr_mem_imm(ctx, v6);

17902

    let v8 = constructor_x64_and(ctx, arg0, arg1, v7);

17903

    let v10 = Imm8Reg::Imm8 { imm: 0x1 };

17904

    let v11 = &C::imm8_reg_to_imm8_gpr(ctx, &v10);

17905

    let v12 = constructor_x64_shr(ctx, arg0, arg1, v11);

17906

    let v13 = &C::gpr_to_gpr_mem_imm(ctx, v6);

17907

    let v14 = constructor_x64_and(ctx, arg0, v12, v13);

17908

    let v15 = &C::imm8_reg_to_imm8_gpr(ctx, &v10);

17909

    let v16 = constructor_x64_shl(ctx, arg0, v8, v15);

17910

    let v17 = &C::gpr_to_gpr_mem_imm(ctx, v14);

17911

    let v18 = constructor_x64_or(ctx, arg0, v16, v17);

17912

    let v20 = C::u64_and(ctx, v2, 0x3333333333333333);

17913

    let v21 = constructor_imm(ctx, arg0, v20);

17914

    let v22 = C::gpr_new(ctx, v21);

17915

    let v23 = &C::gpr_to_gpr_mem_imm(ctx, v22);

17916

    let v24 = constructor_x64_and(ctx, arg0, v18, v23);

17917

    let v26 = Imm8Reg::Imm8 { imm: 0x2 };

17918

    let v27 = &C::imm8_reg_to_imm8_gpr(ctx, &v26);

17919

    let v28 = constructor_x64_shr(ctx, arg0, v18, v27);

17920

    let v29 = &C::gpr_to_gpr_mem_imm(ctx, v22);

17921

    let v30 = constructor_x64_and(ctx, arg0, v28, v29);

17922

    let v31 = &C::imm8_reg_to_imm8_gpr(ctx, &v26);

17923

    let v32 = constructor_x64_shl(ctx, arg0, v24, v31);

17924

    let v33 = &C::gpr_to_gpr_mem_imm(ctx, v30);

17925

    let v34 = constructor_x64_or(ctx, arg0, v32, v33);

17926

    let v36 = C::u64_and(ctx, v2, 0xF0F0F0F0F0F0F0F);

17927

    let v37 = constructor_imm(ctx, arg0, v36);

17928

    let v38 = C::gpr_new(ctx, v37);

17929

    let v39 = &C::gpr_to_gpr_mem_imm(ctx, v38);

17930

    let v40 = constructor_x64_and(ctx, arg0, v34, v39);

17931

    let v42 = Imm8Reg::Imm8 { imm: 0x4 };

17932

    let v43 = &C::imm8_reg_to_imm8_gpr(ctx, &v42);

17933

    let v44 = constructor_x64_shr(ctx, arg0, v34, v43);

17934

    let v45 = &C::gpr_to_gpr_mem_imm(ctx, v38);

17935

    let v46 = constructor_x64_and(ctx, arg0, v44, v45);

17936

    let v47 = &C::imm8_reg_to_imm8_gpr(ctx, &v42);

17937

    let v48 = constructor_x64_shl(ctx, arg0, v40, v47);

17938

    let v49 = &C::gpr_to_gpr_mem_imm(ctx, v46);

17939

    let v50 = constructor_x64_or(ctx, arg0, v48, v49);

17940

    // Rule at src/isa/x64/lower.isle line 1879.

17941

    return v50;

17942

17943

17944

// Generated as internal constructor for term do_bitrev16.

17945

pub fn constructor_do_bitrev16<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

17946

    let v2 = constructor_do_bitrev8(ctx, arg0, arg1);

17947

    let v3 = C::ty_mask(ctx, arg0);

17948

    let v5 = C::u64_and(ctx, v3, 0xFF00FF00FF00FF);

17949

    let v6 = constructor_imm(ctx, arg0, v5);

17950

    let v7 = C::gpr_new(ctx, v6);

17951

    let v8 = &C::gpr_to_gpr_mem_imm(ctx, v7);

17952

    let v9 = constructor_x64_and(ctx, arg0, v2, v8);

17953

    let v11 = Imm8Reg::Imm8 { imm: 0x8 };

17954

    let v12 = &C::imm8_reg_to_imm8_gpr(ctx, &v11);

17955

    let v13 = constructor_x64_shr(ctx, arg0, v2, v12);

17956

    let v14 = &C::gpr_to_gpr_mem_imm(ctx, v7);

17957

    let v15 = constructor_x64_and(ctx, arg0, v13, v14);

17958

    let v16 = &C::imm8_reg_to_imm8_gpr(ctx, &v11);

17959

    let v17 = constructor_x64_shl(ctx, arg0, v9, v16);

17960

    let v18 = &C::gpr_to_gpr_mem_imm(ctx, v15);

17961

    let v19 = constructor_x64_or(ctx, arg0, v17, v18);

17962

    // Rule at src/isa/x64/lower.isle line 1902.

17963

    return v19;

17964

17965

17966

// Generated as internal constructor for term do_bitrev32.

17967

pub fn constructor_do_bitrev32<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

17968

    let v2 = constructor_do_bitrev16(ctx, arg0, arg1);

17969

    let v3 = C::ty_mask(ctx, arg0);

17970

    let v5 = C::u64_and(ctx, v3, 0xFFFF0000FFFF);

17971

    let v6 = constructor_imm(ctx, arg0, v5);

17972

    let v7 = C::gpr_new(ctx, v6);

17973

    let v8 = &C::gpr_to_gpr_mem_imm(ctx, v7);

17974

    let v9 = constructor_x64_and(ctx, arg0, v2, v8);

17975

    let v11 = Imm8Reg::Imm8 { imm: 0x10 };

17976

    let v12 = &C::imm8_reg_to_imm8_gpr(ctx, &v11);

17977

    let v13 = constructor_x64_shr(ctx, arg0, v2, v12);

17978

    let v14 = &C::gpr_to_gpr_mem_imm(ctx, v7);

17979

    let v15 = constructor_x64_and(ctx, arg0, v13, v14);

17980

    let v16 = &C::imm8_reg_to_imm8_gpr(ctx, &v11);

17981

    let v17 = constructor_x64_shl(ctx, arg0, v9, v16);

17982

    let v18 = &C::gpr_to_gpr_mem_imm(ctx, v15);

17983

    let v19 = constructor_x64_or(ctx, arg0, v17, v18);

17984

    // Rule at src/isa/x64/lower.isle line 1914.

17985

    return v19;

17986

17987

17988

// Generated as internal constructor for term do_bitrev64.

17989

pub fn constructor_do_bitrev64<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

17990

    if arg0 == I64 {

17991

        let v2 = constructor_do_bitrev32(ctx, arg0, arg1);

17992

        let v4 = constructor_imm(ctx, arg0, 0xFFFFFFFF);

17993

        let v5 = C::gpr_new(ctx, v4);

17994

        let v6 = &C::gpr_to_gpr_mem_imm(ctx, v5);

17995

        let v7 = constructor_x64_and(ctx, arg0, v2, v6);

17996

        let v9 = Imm8Reg::Imm8 { imm: 0x20 };

17997

        let v10 = &C::imm8_reg_to_imm8_gpr(ctx, &v9);

17998

        let v11 = constructor_x64_shr(ctx, arg0, v2, v10);

17999

        let v12 = &C::imm8_reg_to_imm8_gpr(ctx, &v9);

18000

        let v13 = constructor_x64_shl(ctx, arg0, v7, v12);

18001

        let v14 = &C::gpr_to_gpr_mem_imm(ctx, v11);

18002

        let v15 = constructor_x64_or(ctx, arg0, v13, v14);

18003

        // Rule at src/isa/x64/lower.isle line 1926.

18004

        return v15;

18005

18006

    unreachable!(

18007

        "no rule matched for term {} at {}; should it be partial?",

18008

        "do_bitrev64", "src/isa/x64/lower.isle line 1925"

18009

18010

18011

18012

// Generated as internal constructor for term fmadd.

18013

pub fn constructor_fmadd<C: Context>(

18014

    ctx: &mut C,

18015

    arg0: Type,

18016

    arg1: Value,

18017

    arg2: Value,

18018

    arg3: Value,

18019

) -> Xmm {

18020

    let v24 = C::def_inst(ctx, arg2);

18021

    if let Some(v25) = v24 {

18022

        let v26 = &C::inst_data(ctx, v25);

18023

        if let &InstructionData::Unary {

18024

            opcode: ref v27,

18025

            arg: v28,

18026

        } = v26

18027

18028

            if let &Opcode::Fneg = v27 {

18029

                let v29 = constructor_fnmadd(ctx, arg0, arg1, v28, arg3);

18030

                // Rule at src/isa/x64/lower.isle line 2381.

18031

                return v29;

18032

18033

18034

18035

    let v18 = C::def_inst(ctx, arg1);

18036

    if let Some(v19) = v18 {

18037

        let v20 = &C::inst_data(ctx, v19);

18038

        if let &InstructionData::Unary {

18039

            opcode: ref v21,

18040

            arg: v22,

18041

        } = v20

18042

18043

            if let &Opcode::Fneg = v21 {

18044

                let v23 = constructor_fnmadd(ctx, arg0, v22, arg2, arg3);

18045

                // Rule at src/isa/x64/lower.isle line 2380.

18046

                return v23;

18047

18048

18049

18050

    let v14 = &C::sinkable_load(ctx, arg2);

18051

    if let Some(v15) = v14 {

18052

        let v4 = constructor_put_in_xmm(ctx, arg1);

18053

        let v11 = constructor_put_in_xmm(ctx, arg3);

18054

        let v16 = &constructor_sink_load_to_xmm_mem(ctx, v15);

18055

        let v17 = constructor_x64_vfmadd132(ctx, arg0, v4, v11, v16);

18056

        // Rule at src/isa/x64/lower.isle line 2376.

18057

        return v17;

18058

18059

    let v8 = &C::sinkable_load(ctx, arg1);

18060

    if let Some(v9) = v8 {

18061

        let v10 = constructor_put_in_xmm(ctx, arg2);

18062

        let v11 = constructor_put_in_xmm(ctx, arg3);

18063

        let v12 = &constructor_sink_load_to_xmm_mem(ctx, v9);

18064

        let v13 = constructor_x64_vfmadd132(ctx, arg0, v10, v11, v12);

18065

        // Rule at src/isa/x64/lower.isle line 2375.

18066

        return v13;

18067

18068

    let v4 = constructor_put_in_xmm(ctx, arg1);

18069

    let v5 = constructor_put_in_xmm(ctx, arg2);

18070

    let v6 = &C::put_in_xmm_mem(ctx, arg3);

18071

    let v7 = constructor_x64_vfmadd213(ctx, arg0, v4, v5, v6);

18072

    // Rule at src/isa/x64/lower.isle line 2370.

18073

    return v7;

18074

18075

18076

// Generated as internal constructor for term fnmadd.

18077

pub fn constructor_fnmadd<C: Context>(

18078

    ctx: &mut C,

18079

    arg0: Type,

18080

    arg1: Value,

18081

    arg2: Value,

18082

    arg3: Value,

18083

) -> Xmm {

18084

    let v24 = C::def_inst(ctx, arg2);

18085

    if let Some(v25) = v24 {

18086

        let v26 = &C::inst_data(ctx, v25);

18087

        if let &InstructionData::Unary {

18088

            opcode: ref v27,

18089

            arg: v28,

18090

        } = v26

18091

18092

            if let &Opcode::Fneg = v27 {

18093

                let v29 = constructor_fmadd(ctx, arg0, arg1, v28, arg3);

18094

                // Rule at src/isa/x64/lower.isle line 2389.

18095

                return v29;

18096

18097

18098

18099

    let v18 = C::def_inst(ctx, arg1);

18100

    if let Some(v19) = v18 {

18101

        let v20 = &C::inst_data(ctx, v19);

18102

        if let &InstructionData::Unary {

18103

            opcode: ref v21,

18104

            arg: v22,

18105

        } = v20

18106

18107

            if let &Opcode::Fneg = v21 {

18108

                let v23 = constructor_fmadd(ctx, arg0, v22, arg2, arg3);

18109

                // Rule at src/isa/x64/lower.isle line 2388.

18110

                return v23;

18111

18112

18113

18114

    let v14 = &C::sinkable_load(ctx, arg2);

18115

    if let Some(v15) = v14 {

18116

        let v4 = constructor_put_in_xmm(ctx, arg1);

18117

        let v11 = constructor_put_in_xmm(ctx, arg3);

18118

        let v16 = &constructor_sink_load_to_xmm_mem(ctx, v15);

18119

        let v17 = constructor_x64_vfnmadd132(ctx, arg0, v4, v11, v16);

18120

        // Rule at src/isa/x64/lower.isle line 2385.

18121

        return v17;

18122

18123

    let v8 = &C::sinkable_load(ctx, arg1);

18124

    if let Some(v9) = v8 {

18125

        let v10 = constructor_put_in_xmm(ctx, arg2);

18126

        let v11 = constructor_put_in_xmm(ctx, arg3);

18127

        let v12 = &constructor_sink_load_to_xmm_mem(ctx, v9);

18128

        let v13 = constructor_x64_vfnmadd132(ctx, arg0, v10, v11, v12);

18129

        // Rule at src/isa/x64/lower.isle line 2384.

18130

        return v13;

18131

18132

    let v4 = constructor_put_in_xmm(ctx, arg1);

18133

    let v5 = constructor_put_in_xmm(ctx, arg2);

18134

    let v6 = &C::put_in_xmm_mem(ctx, arg3);

18135

    let v7 = constructor_x64_vfnmadd213(ctx, arg0, v4, v5, v6);

18136

    // Rule at src/isa/x64/lower.isle line 2383.

18137

    return v7;

18138

18139

18140

// Generated as internal constructor for term cmp_zero_i128.

18141

pub fn constructor_cmp_zero_i128<C: Context>(

18142

    ctx: &mut C,

18143

    arg0: &CC,

18144

    arg1: ValueRegs,

18145

) -> IcmpCondResult {

18146

    let v1 = &C::cc_nz_or_z(ctx, arg0);

18147

    if let Some(v2) = v1 {

18148

        let v5 = constructor_value_regs_get_gpr(ctx, arg1, 0x0);

18149

        let v7 = constructor_value_regs_get_gpr(ctx, arg1, 0x1);

18150

        let v10 = RegMemImm::Imm { simm32: 0x0 };

18151

        let v11 = &C::gpr_mem_imm_new(ctx, &v10);

18152

        let v12 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v11, v5);

18153

        let v14 = &constructor_x64_setcc(ctx, &CC::Z);

18154

        let v15 = constructor_with_flags_reg(ctx, v12, v14);

18155

        let v16 = C::gpr_new(ctx, v15);

18156

        let v17 = &C::gpr_mem_imm_new(ctx, &v10);

18157

        let v18 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v17, v7);

18158

        let v19 = &constructor_x64_setcc(ctx, &CC::Z);

18159

        let v20 = constructor_with_flags_reg(ctx, v18, v19);

18160

        let v21 = C::gpr_new(ctx, v20);

18161

        let v23 = &C::gpr_to_gpr_mem_imm(ctx, v16);

18162

        let v24 = &constructor_x64_test(ctx, &OperandSize::Size8, v23, v21);

18163

        let v25 = &constructor_icmp_cond_result(ctx, v24, v2);

18164

        // Rule at src/isa/x64/lower.isle line 2821.

18165

        return v25.clone();

18166

18167

    unreachable!(

18168

        "no rule matched for term {} at {}; should it be partial?",

18169

        "cmp_zero_i128", "src/isa/x64/lower.isle line 2820"

18170

18171

18172

18173

// Generated as internal constructor for term cmp_zero_int_bool_ref.

18174

pub fn constructor_cmp_zero_int_bool_ref<C: Context>(ctx: &mut C, arg0: Value) -> ProducesFlags {

18175

    let v1 = C::value_type(ctx, arg0);

18176

    let v2 = &C::raw_operand_size_of_type(ctx, v1);

18177

    let v3 = constructor_put_in_gpr(ctx, arg0);

18178

    let v4 = &C::gpr_to_gpr_mem_imm(ctx, v3);

18179

    let v5 = &constructor_x64_test(ctx, v2, v4, v3);

18180

    // Rule at src/isa/x64/lower.isle line 2832.

18181

    return v5.clone();

18182

18183

18184

// Generated as internal constructor for term nonzero_sdiv_divisor.

18185

pub fn constructor_nonzero_sdiv_divisor<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Reg {

18186

    let v2 = C::def_inst(ctx, arg1);

18187

    if let Some(v3) = v2 {

18188

        let v4 = &C::inst_data(ctx, v3);

18189

        if let &InstructionData::UnaryImm {

18190

            opcode: ref v5,

18191

            imm: v6,

18192

        } = v4

18193

18194

            if let &Opcode::Iconst = v5 {

18195

                let v7 = C::safe_divisor_from_imm64(ctx, arg0, v6);

18196

                if let Some(v8) = v7 {

18197

                    let v9 = constructor_imm(ctx, arg0, v8);

18198

                    // Rule at src/isa/x64/lower.isle line 3425.

18199

                    return v9;

18200

18201

18202

18203

18204

    let v10 = C::put_in_reg(ctx, arg1);

18205

    let v11 = &C::raw_operand_size_of_type(ctx, arg0);

18206

    let v12 = &constructor_reg_to_gpr_mem_imm(ctx, v10);

18207

    let v13 = C::gpr_new(ctx, v10);

18208

    let v14 = &constructor_x64_test(ctx, v11, v12, v13);

18209

    let v17 = &constructor_trap_if(ctx, &CC::Z, &TrapCode::IntegerDivisionByZero);

18210

    let v18 = &constructor_with_flags_side_effect(ctx, v14, v17);

18211

    let v19 = constructor_side_effect(ctx, v18);

18212

    // Rule at src/isa/x64/lower.isle line 3428.

18213

    return v10;

18214